Software testing tutorials and automation

5 Options to Combine Two Columns in Excel (With space, comma, and dash)

noreply@blogger.com (Unknown) — Tue, 18 Mar 2025 12:58:00 +0000

Ever had two columns of data in Excel that you want to merge magically into one column?

Suppose, You have a first name in one column, and the last names are in another, and you want to merge them into one clean list—without spending hours copy-pasting.

It is a time-consuming and tedious task to copy and paste each one manually.

Here is some good news: There’s a super simple way to combine columns in Excel… and I will show you exactly how.

No stress, no fuss. This quick guide walks you through five simple ways to get it done.

When Would You Need This?

Before we dive in, here are a few common reasons you might want to combine columns:

Creating full names from first and last names
Joining product names with categories or codes
Merging address fields into a single-line
Cleaning up messy data so it’s easier to read or export

Sound familiar? Cool. Let’s get into it.

The Fastest Way to Combine Two Columns with a Space in Excel

Imagine this setup:

Column C has the first names.
Column D has the last names. Now you want a full name in Column E, with a space in between.

Option 1: Use a Simple Formula (The & Trick) to Combine Two Columns

Steps to join columns using & (Ampersand)

To combine two columns in Excel:

Click/Select E2 cell.
Type in this formula: = C2 & " " & D2

Hit the Enter button and boom—Excel combines the two!

What’s Happening Here?

C2 is your first column i.e. "Elizabeth"
" " adds a space.
D2 is your second column i.e. "Smith"
When you press the Enter button, you’ll get Elizabeth Smith in E2.

Easy, right?

Now, Grab that little square (+ sign) in the bottom-right corner of the E2 cell (the fill handle) and drag it down to copy the formula to the rest of your rows.

We applied the same formula to the remaining rows.

Merge using comma(,) and Dash(-)

You can use:

= C2 & "," & D2 formula to combine using the comma.
= C2 & "-" & D2 formula to merge using the dash in between.

Use of TEXT Function (For Formatting and Combining Numbers/Dates)

If you’re combining numbers or dates and want them formatted nicely, use TEXT() inside your formula.

Example: =B2 & ". " & C2 & " " & D2 & " - " & TEXT(E2, "mm/dd/yyyy")

Here you can see that Colum B has a number and E has a date. We applied the TEXT() function to merge all four column values in the F column.

Tips: If you want to combine more than two columns i.e. B2, C2, and D2, You can use the formula = B2 & " " & C2 & " " & D2

Other Ways to Combine Two Columns (If You’re Feeling Fancy)

Here are other options which you can use to combine two or more columns of data.

Option 2: Use TEXTJOIN()

This function is perfect for working with more than two columns or for ignoring blank cells.

Suppose you have a scenario in which a First name is in column C, a Last name is in Column D, an Address is in column E and a few cells are empty. You want to combine them in column F.

Steps to join cells using TEXTJOIN function.

Select cell F2.
Type in formula =TEXTJOIN(", ", "", C2, D2, E2)
Hit Enter.

What’s Happening Here?

The " " part is your separator (in this case, a space). You can use comma or dash as a separator if you need.
TRUE skips any blanks.

In the above image, you can see that we have used the TEXTJOIN function to merge data from C, D, and E columns into F.

Quick Tip: If you type =TEXTJOIN in a cell and it shows a #NAME? error, your Excel (Excel 2016 or earlier versions) version probably doesn’t support it. This function was introduced in Excel 2019 and is available in Excel 365 (Microsoft 365), Excel 2019 for Windows and Mac, and Excel Online (browser version).

Option 3: Use CONCAT() (For Newer Versions of Excel)

If you’ve got Excel 2019 or newer, you can try the CONCAT() function. This is basically an upgrade from CONCATENATE().

We will use the same example as described in option 2 to merge three columns.

A step-by-step guide to joining cells using the TEXTJOIN function.

Click on cell F2.
Write formula =CONCAT(C2, " ", D2, " ", E2)
Press the Enter key from the keyboard.

Why CONCAT() instead of CONCATENATE()

Starting with Excel 2016, Microsoft introduced the CONCAT() function as a more powerful and flexible replacement for CONCATENATE().

Key points:

CONCATENATE() is still available in Excel 2016 and later versions for backward compatibility, but it's considered deprecated.
Microsoft recommends using CONCAT() or TEXTJOIN() (introduced in Excel 2016) going forward.

Option 4: Flash Fill (The Lazy Person’s Hack!)

Flash Fill is Excel’s auto-magic tool that detects patterns and fills in the rest for you. No formula is required!

How to use it:

In E2, manually type Elizabeth Smith as per our example.
Press the Enter button. Cursor will move on E3

Start typing the next combined value in E3, like: Maria.

Excel will recognize the pattern and show flash-fill suggestions.
Press the Enter button. Boom! The remaining cells will be filled automatically with the same pattern.

This is the perfect option for quick-and-dirty tasks, no formulas left behind!

Option 5: Combine Two Columns Using VBA Macro

Scenario:

You have First Names in Column C and Last Names in Column D, and you want to combine them into Column E, separated by a space.

Steps:

Step 1: Open Your Excel Workbook

Make sure your workbook has the data in the C and D columns

For example:

Step 2: Access the VBA Editor

Press Alt + F11 on your keyboard.

This opens the VBA Editor window.

In the editor, click Insert > Module.

A new blank code window will appear where you can write your macro.

Step 3: Paste the VBA Code

Here’s a simple macro to combine columns C and D into column E:

Sub CombineColumns()
    Dim ws As Worksheet
    Dim lastRow As Long
    Dim i As Long

    'Set your worksheet (ActiveSheet means the sheet you're currently on)
    Set ws = ActiveSheet

    'Find the last row with data in column C
    lastRow = ws.Cells(ws.Rows.Count, "C").End(xlUp).Row

    'Loop through each row to combine data
    For i = 2 To lastRow
        ws.Range("E" & i).Value = ws.Range("C" & i).Value & " " & ws.Range("D" & i).Value
    Next i

    MsgBox "Columns Combined Successfully!", vbInformation
End Sub

Step 4: Close the VBA Editor

Click the X to close the editor.
Go back to your Excel sheet.

Step 5: Run the Macro

Press Alt + F8

This opens the "Macro" dialog box.

Select CombineColumns from the list.
Click Run.

What Happens?

The macro loops through each row of your data (starting from row 2), combines the First Name and Last Name from columns C and D, and places the full name in column E.

For example:

C2 = Elizabeth
D2 = Smith
E2 becomes Elizabeth Smith

Breakdown of the VBA Code

Dim ws As Worksheet: Declares a worksheet variable.
Set ws = ActiveSheet: Sets the active sheet as your working sheet.
lastRow = ws.Cells(...).End(xlUp)...: Finds the last row in column C with data.
For i = 2 To lastRow: Loops from row 2 to the last row.
ws.Range("E" & i).Value = ...: Combines the values and writes to column E.
MsgBox: Pops up a message when it’s done.

Bonus: Add a Button to Run the Macro (Optional, But Fun!)

Want to click a button instead of pressing Alt + F8 every time?

Here’s how:

Go to the Developer tab. (If you don’t see it, go to File > Options > Customize Ribbon > Check Developer and click OK.)
Click Insert > Button (Form Control).
Draw your button anywhere on your sheet.
When prompted, assign your macro (CombineColumns) to it.
Right-click the button to edit the text (call it "Combine Names" or whatever you like).

Now just click your button, and the macro will run automatically!

Practice Makes Perfect! Download Your Excel Exercise Sheet

Learning how to combine columns in Excel is one thing… but practicing it? That’s where the real magic happens.

I’ve put together an exercise sheet just for you! Inside, you’ll find ready-made data to practice:

Simple & formulas
TEXTJOIN() and CONCAT() methods
Flash Fill tricks
Even a spot to run your first VBA macro!

Click below to download your practice workbook (it’s free!):

Download the Excel Exercise Sheet Now!

(It’s a .xlsx file, totally safe, and won’t ask for your email.)

What’s Inside the Exercise Sheet?

Here’s a sneak peek of what you’ll get:

First Names and Last Names in Columns C and D to practice combining into Column E
Tasks for:

Combining columns with a space, comma, or dash.
Ignoring blank cells using TEXTJOIN()
Creating full names with prefixes/suffixes
Running a simple VBA macro to automate the process

A step-by-step guide right in the sheet so you won’t get lost!

How to Use It

Download the file and open it in Excel.
Start with Sheet 1, where you’ll practice basic formulas.
Move to the Advanced Methods sheet for TEXTJOIN(), CONCAT(), and VBA.
Challenge yourself by solving the Bonus Tasks I’ve included!

Why Practice With This Sheet?

It’s hands-on, not just theory
You can see the formulas in action
Perfect if you want to learn by doing
Helps build muscle memory, so combining columns becomes second nature!

Quick Tips to Keep in Mind

Customize your separator: Use a comma, hyphen, dash, or anything else. Just replace the " " with whatever you need.
Lock the combined values: If you want to get rid of formulas, copy Column E, then right-click and choose Paste Values.
Works with numbers too: Combine product codes, IDs, anything.

Wrapping Up

Combining two columns in Excel is easy once you know how. Whether you’re merging names, product details, or anything else, these quick tricks can save you a ton of time.

Next time you’re cleaning up a spreadsheet, give these methods a try!

And if you want more time-saving Excel tips, let me know—I’d love to share more.

Partial Link Text in Selenium: When and How to Use It Effectively

noreply@blogger.com (Unknown) — Thu, 13 Mar 2025 04:41:00 +0000

Are you trying to locate a hyperlink by linkText, but it doesn't work in Selenium automation? You’re not alone.

If the text of the link is changing dynamically, then linkText doesn't work as it will look for the exact text of the hyperlink.

Here is the solution for this problem.

You can use partial link text instead of the linkText element locator to locate such dynamic generated hyperlinks.

This article will teach you what partial link text is, how and when to use partial link text in Selenium automation.

What is partial link text in Selenium WebDriver?

ByPartialLinkText is a static inner class inside the By class.

It extends By and implements the locator strategy to find elements by partial link text.

To understand it easily, the partialLinkText is a locator strategy in Selenium WebDriver that allows you to locate anchor elements (<a> tags) by matching a part of the visible text of the hyperlink. that's it.

Why Use partialLinkText?

Using partial link text, you do not need full link text to identify the element.

I use it when the link text is too long, the text changes dynamically, or part of the text is predictable.

Another reason why I am using it is that it makes my tests more flexible.

How It Works

When you use it in an automation test, Selenium will scan the DOM for <a> elements. It will check for visible text (between <a> and </a>) that contains the substring that you have specified in code.

For example, consider the following HTML of a hyperlink.

<a href="https://example.com">Learn Selenium with Examples</a>

If you are working with Java Selenium, you can locate this link using:

WebElement link = driver.findElement(By.partialLinkText("Learn Selenium"));

WebElement link = driver.findElement(By.partialLinkText("with Examples"));

PartialLinkText syntax for Python Selenium is:

link = driver.find_element(By.PARTIAL_LINK_TEXT, "with Examples")

and for C# is:

IWebElement link = driver.FindElement(By.PartialLinkText("with Examples"));

Let me clarify that it works with anchor tags (<a>) only. So, do not try to locate other web elements like button, <button>, textbox, <input>, etc. using partial link text. It will not work with them.

Is it clear now? I think so.

Now let's dive into the examples..

Using PartialLinkText In Selenium: Step by Step

If you are a beginner, this step-by-step guide will help you understand how to use partial link text practically.

Step 1: Set up and configure Selenium in Eclipse

This guide will help you to understand how to download and install Selenium WebDriver in Eclipse IDE.

Step 2: Download and install Chrome Driver

I have already written a step-by-step tutorial on how to download and install Chrome Driver. You can refer to it.

Step 3: Create a project & write a code in Eclipse

You can create a new project and write the following code in the class file.

Before running this code, remember to replace the Chrome driver path, the test URL, and the link text with your actual one.

Java Example Code

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

public class PartialLinkTextExample {
    public static void main(String[] args) {

        // Set the path to your ChromeDriver executable if necessary
        // System.setProperty("webdriver.chrome.driver", "path/to/chromedriver");

        // Initialize ChromeDriver (Selenium 4 style)
        WebDriver driver = new ChromeDriver();

        // Open a webpage
        driver.get("https://example.com");

        // Locate the <a> element using partialLinkText
        WebElement link = driver.findElement(By.partialLinkText("Learn"));

        // Click the link
        link.click();

        // Close the browser
        driver.quit();
    }
}

Step 4: Run the code

When you run the above code, it will open the Chrome browser, navigate to your given URL, locate an element by partial link text, click on it, and then close the browser.

Are you working in Python or C#? Don't worry. I have examples in both these languages as well.

Here they are:

Python Example Code

from selenium import webdriver
from selenium.webdriver.common.by import By

# Initialize the driver (Selenium 4 style)
driver = webdriver.Chrome()

driver.get("https://example.com")

# Find an <a> element containing "Learn" in its text
link = driver.find_element(By.PARTIAL_LINK_TEXT, "Learn")

# Perform click action
link.click()

# Close the driver
driver.quit()

C# Example Code

using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;

class Program
{
    static void Main(string[] args)
    {
        IWebDriver driver = new ChromeDriver();

        driver.Navigate().GoToUrl("https://example.com");

        // Locate <a> element with partial link text "Learn"
        IWebElement link = driver.FindElement(By.PartialLinkText("Learn"));

        // Click the link
        link.Click();

        // Close the browser
        driver.Quit();
    }
}

So, that's it on how to use partialLinkText in selenium.

But you should know how to use it efficiently, right?

Let's jump on best practices.

Best Practices for Using partialLinkText

Here are some important things to consider to prevent errors and improve test execution performance.

Use Unique Substrings

Always prefer using a unique substring. If text is changing frequently, your test will fail. This is a very very important point.

Avoid Common Words

We generally find common words like "Click" and "More" many times on the page. Avoid using such words to locate an element by partial link text.

Prefer linkText When You Know the Full Link Text

If text is unique and static, then you can use the linkText locator.

Interview Tip!

If the interviewer asks you a question, "When would you use partialLinkText over other locators?"

You can say: When I need to locate a link with long or dynamic visible text, and I know a unique part of that text, I use partialLinkText. It simplifies the locator and avoids brittle XPath expressions.

Winding Up

In summary, partialLinkText is a handy locator strategy in Selenium WebDriver when you need to interact with hyperlinks by matching only a portion of their visible text.

That's it. Any question or query? You can ask me your doubt by commenting below.

What is linkText in Selenium? Ultimate Guide for Beginners

noreply@blogger.com (Unknown) — Tue, 11 Mar 2025 11:14:00 +0000

Do you know how to click on the link without using complicated locators like XPath and CSS selectors? linkText in Selenium is a specially designed element locator that locates and interacts with hyperlinks on a page. Whether you are just starting out or looking to use it effectively in your selenium tests, this guide will help you understand how Link Text works, when to use it, and a few tips to make your automation scripts cleaner and more reliable.

What is linkText in Selenium?

ByLinkText is a concrete class inside the By class in Selenium. It is responsible for finding elements by the exact visible link text.

In simple words, linkText is a locator strategy in Selenium WebDriver that is used to identify hyperlinks (<a> tags) on a web page by their exact visible text.

How It Works behind the scenes:

When you use this Selenium locator in a test, it will search for an <a> tag whose text content exactly matches the string you pass.

If Selenium finds a hyperlink with matching text, it will interact with it to perform your given task like click on it, get text, etc.

When to Use

You can use it when:

link text is unique on the page.
It is static and doesn’t change dynamically.
You are looking for a quick and easy way to locate a hyperlink.

Syntax of linkText

I don't know in which language you are working. Selenium supports multiple languages. So I am providing link text locator syntax for popular languages, Java, Python, and C#.

Java Syntax

driver.findElement(By.linkText("Exact Link Text")).click();

Python Syntax

driver.find_element(By.LINK_TEXT, "Exact Link Text").click()

C# Syntax

driver.FindElement(By.LinkText("Exact Link Text")).Click();

Step-by-Step: Using linkText in Selenium

Here is a step-by-step guide on how to use link text element locator in Selenium WebDriver.

Step 1: Set Up Selenium WebDriver

Make sure that selenium is installed and configured properly in your project. If not configured, you can follow these Selenium installation guidelines.

// Import necessary Selenium packages
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

Step 2: Update Chrome Browser and Download Latest ChromeDriver

For beginners, it is recommended to run initial tests on the Chrome browser. So, update your Chrome browser to the latest version and download the latest version of ChromeDriver. Here is a guideline to download the latest version of ChromeDriver and update the Chrome browser.

If you are using the Edge browser, here is a guide on how to download the latest EdgeDriver for Selenium.

Step 3: Launch the Browser

Create a WebDriver instance and open a browser (like Chrome).

// Set up ChromeDriver path (optional depending on your setup)
System.setProperty("webdriver.chrome.driver", "path/to/chromedriver");

// Launch Chrome browser
WebDriver driver = new ChromeDriver();

Step 4: Navigate to the Web Page

Open the website where you want to click a link. We will use an example link. You can replace it with your testing URL.

driver.get("https://example.com");

Step 5: Locate the Link by Its Text and Click on It

Use By.linkText() method to find the link with the exact visible text and click() method to click on it. You need to replace link text, i.e. "Exact Link Text" as per your original link text.

//Locate link by exact link text
WebElement yourLinkText = driver.findElement(By.linkText("Click Here"));

//click on link
yourLinkText.click();

The above code will locate and click on the link.

Tips:

Exact Text Match: It is case-sensitive. Also make sure you are using exact text.
Only for <a> Tags: This locator strategy works only with anchor tags (<a> elements).
Avoid Extra Spaces: Remove leading/trailing whitespace from text.
Use partialLinkText(): If you know only part text of the link, use partialLinkText() instead of linkText().

Common Use Cases:

You can use this method for the below given real world test scenarios.

Navigating to different pages through hyperlinks.
Clicking buttons styled as links.
Automating simple workflows with clickable link text.

linkText examples in Java, Python, and C# for Selenium WebDriver

Here is a basic example code for learners on how to use linkText in Java, Python, and C# languages.

Note: Please replace chromedriver path, test URL, and link text with your own ones before running any of the below given examples.

Java Example

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

public class LinkTextExample {
    public static void main(String[] args) {

        // Set path to chromedriver if necessary
        System.setProperty("webdriver.chrome.driver", "path/to/chromedriver");

        // Initialize the ChromeDriver
        WebDriver driver = new ChromeDriver();

        try {
            // Open the webpage
            driver.get("https://example.com");

            // Find the link by its exact text and click it
            WebElement link = driver.findElement(By.linkText("Contact Us"));
            link.click();

        } finally {
            // Close the browser
            driver.quit();
        }
    }
}

Python Example

from selenium import webdriver
from selenium.webdriver.common.by import By

# Initialize the Chrome driver
driver = webdriver.Chrome()

try:
    # Open the webpage
    driver.get("https://example.com")

    # Find the link by its exact text and click it
    link = driver.find_element(By.LINK_TEXT, "Contact Us")
    link.click()

finally:
    # Close the browser
    driver.quit()

C# Example

using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;

class LinkTextExample
{
    static void Main(string[] args)
    {
        // Initialize ChromeDriver
        IWebDriver driver = new ChromeDriver();

        try
        {
            // Open the webpage
            driver.Navigate().GoToUrl("https://example.com");

            // Find the link by its exact text and click it
            IWebElement link = driver.FindElement(By.LinkText("Contact Us"));
            link.Click();
        }
        finally
        {
            // Close the browser
            driver.Quit();
        }
    }
}

The above examples will demonstrate to you how to use the linkText element locator to click on a link.

Handling Multiple Links with Identical Link Text

If Selenium will find multiple links with the same link text on the page, it will only return the first matching element.

Example Scenario:

Suppose a page has hyperlinks like below.

<a href="https://example.com/pagex">View Product</a>
<a href="https://example.com/pagey">View Product</a>
<a href="https://example.com/pagez">View Product</a>

If you run this in Selenium:

WebElement link = driver.findElement(By.linkText("View Product"));
link.click();

Selenium will click only the first <a> element:

<a href="https://example.com/pagex">View Product</a>

When multiple links are present on the page, and if you want to click on the second link, then you can use the following code.

// Find all links with the exact link text
List<WebElement> links = driver.findElements(By.linkText("View Product"));

// Click the second link (index 1, since list is zero-based)
if (links.size() >= 2) {
    links.get(1).click();
} else {
    System.out.println("Second link not found!");
}

Here, we have used the findElements method to get a list of links from the page with the View Product text. Then the code will check if more than two links are present in the list, then it will kick on the second link using the index value.

However, it is advised to use XPath i.e. By.xpath("(//a[text()='View Product'])[2]") if multiple links with the same text are present on the page and you want to click on a specific link.

If you want to click on all three links, you can use a for loop to iterate and click on them one by one, as the example below.

List<WebElement> links = driver.findElements(By.linkText("View Product"));

for (WebElement link : links) {
    System.out.println(link.getAttribute("href")); // Prints each link's URL
    // link.click();  // Optional: Click each link (but be cautious, as clicking may navigate away)
}

Pro Tip!: Do not use linktext locator in Selenium if text of link changes frequently. Instead you can use partialLinkText, XPath, or CSS selectors.

Real world Examples

Using the link text element locator, you can not only click on the link. But you can use it for many different purposes. Here are practical examples on how and when you can use linkText in Selenium automation.

Example 1: Extract and Print the Link Text

You can get and print the text of a link to verify if it's correct.

// Find the link element
WebElement link = driver.findElement(By.linkText("About Us"));

// Get the visible text of the link
String linkText = link.getText();

// Print the link text
System.out.println("Link Text is: " + linkText);

Example 2: Retrieve the URL (href Attribute) of the Link

You can fetch the href value to verify if the URL is correct or not.

WebElement link = driver.findElement(By.linkText("Contact Us"));

// Get the 'href' attribute value (the destination URL)
String linkURL = link.getAttribute("href");

System.out.println("The link points to: " + linkURL);

Example 3: Count How Many Links Are on the Page with Specific Text

You can find out how many times a link with a specific text appears on a page.

List<WebElement> links = driver.findElements(By.linkText("Click here"));

System.out.println("Number of 'Cclick here' links: " + links.size());

Example 4: Verify If a Specific Link Is Displayed/Enabled

You can check if a link is visible or enabled on the page before performing actions.

WebElement link = driver.findElement(By.linkText("Terms of Service"));

if(link.isDisplayed() && link.isEnabled()) {
    System.out.println("The link is visible and clickable.");
} else {
    System.out.println("The link is not ready to interact with.");
}

Example 5: Validate Broken Links Without Clicking

You can use it to locate a link and then send an HTTP request to the href URL to check if the link is broken or working.

WebElement link = driver.findElement(By.linkText("About Us"));

String linkURL = link.getAttribute("href");

// (Assume you have an HTTP client here)
if(checkIfLinkIsBroken(linkURL)) {
    System.out.println("The link is broken: " + linkURL);
} else {
    System.out.println("The link works fine!");
}

So this way, you can use it for different purposes.

Difference Between linkText and partialLinkText

Main difference between link text and partial link text is: linkText matches the full visible text of the link while partialLinkText matches part of the link text. linkText is a strict element locator, but partialLinkText is more flexible.

Advantages:

Here is a list of advantages of using linktext locator in Selenium automation.

Simple and Readable: It is very simple to understand.
Precise: Very useful locator when the link text is unique.
Direct: No need to deal with complex locators like XPath or CSS.

Limitations:

Please consider these limitations before using linktext locator in your automation tests.

Exact Match Required: If the text of the link changes or has a leading/trailing space, it can fail.
Case-Sensitive: Some browsers treat links differently. Use the same link text as per actual on the page.
Not for Partial Matches: It doesn’t work if you only know part of the text.

Best Practices

Follow these best practices for better performance in Selenium automation when using link text.

Ensure Uniqueness: Make sure the link text is unique on the page.
Avoid Long or Dynamic Texts: If the link text is long or dynamic, prefer to use partialLinkText, XPath, or CSS Selectors.
Trim Spaces: Remove extra spaces in the text.
Localization: Avoid linkText for multilingual pages.

Final Words

linkText is a simple and beginner-friendly locator strategy in Selenium WebDriver. It’s highly effective when you need to interact with hyperlinks that have clear, static, and unique visible text.

TagName Locator in Selenium WebDriver: Everything You Need to Know

noreply@blogger.com (Unknown) — Mon, 10 Mar 2025 13:12:00 +0000

Element locators play an important part in interacting with elements in Selenium tests. Let me clarify here that Selenium supports lots of element locators like ID, Name, XPath, CSS Selectors, tagName, linkText, partialLinkText. All the element locators have their own advantages and disadvantages. Let us see what the tagName locator in Selenium, how it works, and when to use it in real-time test automation scenarios.

What is TagName Locator in Selenium?

By.ByTagName is an inner static class inside the By class in Selenium. It represents the By.tagName(String tagName) locator strategy.

TagName locator is a simple and very powerful element locator in Selenium. One can use it to locate an element by HTML tags such as <input>, <a>, <div>, <button>, <h1>, etc. It allows to interact with all the links on a page or loop through rows in a table. Also, you can use it to find elements of a specific tag type, either a single element or a group of them.

When and Why to Use TagName Locator?

There are many other power locators available in Selenium. So why or when to use the tagname locator?

Here are some real world scenarios where you can prefer to use it instead of other element locators.

Count the number of elements on the page using the tag name

Suppose you have a test scenario or requirement to count how many links or buttons are present on a page. You can count it easily using the tag name locator.

Here is an example in Java

         // Find all elements with tag name 'a'
        List<WebElement> links = driver.findElements(By.tagName("a"));

        // Count the number of 'a' tags
        int count = links.size();

        // Print the count
        System.out.println("Number of <a> tags on the page: " + count);

In the above example, findElements(By.tagName("a")) will find all elements with the <a> tag and size() gives the count of those elements.

When other element locators are not available

Sometimes, elements do not have any attribute but have a tag name only. In this case, it is easy to locate the element based on its tag name instead of slower element locators like XPath and CSS selectors.

Easy to find the child elements

You can use it to find a child element which is located inside a parent element, such as getting all rows <tr> from a table.

Here is an example in Python to read data from the table using tag name.

    # Locate the table (optional if you want to focus on a specific table)
    table = driver.find_element(By.ID, "customers")

    # Find all rows (<tr>) inside the table
    rows = table.find_elements(By.TAG_NAME, "tr")

    # Print the number of rows
    print(f"Total number of rows: {len(rows)}")

    # Optional: Print the text in each row
    for index, row in enumerate(rows):
    print(f"Row {index}: {row.text}")

In this example, find_elements(By.TAG_NAME, "tr") will find all the <tr> elements (rows) inside that table. Then len(rows) will count the number of rows and row.text will get the text content of each row.

How TagName Works (Behind the Scenes)

When you use By.tagName() in Selenium test, it will search for your provided HTML tag name on the page

For example:

<a href="https://example.com">Click Me</a>

In this case, if you use By.tagName("a"), it finds the anchor element from the given HTML structure.

How to find the Tag Name of an element from the page

To find the tag name of the element, you can:

Right click on element.
Select inspect element.

You can get the tag name of the element as shown in the given image.

Java, Python, and C# Syntax to use TagName Locator in Selenium

Java syntax

//To find single element
WebElement element = driver.findElement(By.tagName("tagname"));

//To find multiple elements
List<WebElement> elements = driver.findElements(By.tagName("tagname"));

Python syntax

//To find single element
element = driver.find_element(By.TAG_NAME, "tagname")

//To find multiple elements
elements = driver.find_elements(By.TAG_NAME, "tagname")

C# syntax

//To find single element
IWebElement element = driver.FindElement(By.TagName("tagname"));

//To find multiple elements
IReadOnlyCollection<IWebElement> elements = driver.FindElements(By.TagName("tagname"));

Practical Examples of Using TagName Locator

Here are some examples of using the tagName locator to understand it better.

Example 1: Find a header tag using TagName

// Find the first <h1> tag on the page
WebElement heading = driver.findElement(By.tagName("h1"));
System.out.println("Heading Text: " + heading.getText());

In this example, it will locate the first h1 tag using By.tagName("h1") and get the header text using heading.getText() and print it in the console.

Example 2: Find All Links on a Web Page

// Find all <a> tags (links)
List<WebElement> allLinks = driver.findElements(By.tagName("a"));

System.out.println("Total Links: " + allLinks.size());

for (WebElement link : allLinks) {
    System.out.println(link.getText() + " - " + link.getAttribute("href"));
}

In the above example, findElements(By.tagName("a")) will find all elements having tag name a. allLinks.size() will calculate how many links and print it in the console. The next for loop is used to extract link text using link.getText() and print it in the console.

Example 3: Count All Input Fields on a Form

// Find all <input> fields
List<WebElement> inputFields = driver.findElements(By.tagName("input"));

System.out.println("Number of input fields: " + inputFields.size());

You can use the above example to calculate how many input fields are present on the page.

Step by step how to use tagName in Selenium

Step 1: Download and install browser driver

First of all, you need to download the browser driver, i.e. ChromeDriver, to run tests in Chrome browser. Here is a guide on how to download and configure Selenium Chrome Driver.

Step 2: Download and Configure Selenium in your project

Next step is to download and configure Selenium in your project. You can do it manually or use a Maven-like framework to set up Selenium. Here is step by step guide on how to download and install Selenium Webdriver with Eclipse.

Step 3 Launch browser and run test

Now you can use the following examples to run tests in Java, Python, and C# languages. These examples will demonstrate how to use the tagName in Selenium tests.

tagName Selenium Example in Java

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import java.util.List;

public class TagNameExample {
    public static void main(String[] args) {
        // Set the path to your chromedriver executable if needed
        System.setProperty("webdriver.chrome.driver", "path/to/chromedriver");

        WebDriver driver = new ChromeDriver();

        // Step 3: Open a website
        driver.get("https://example.com");

        // Step 4: Find a single element by tag name
        WebElement firstParagraph = driver.findElement(By.tagName("p"));
        System.out.println("First paragraph text: " + firstParagraph.getText());

        // Step 5: Find multiple elements by tag name
        List<WebElement> allLinks = driver.findElements(By.tagName("a"));
        System.out.println("Total links: " + allLinks.size());

        // Step 6: Close browser
        driver.quit();
    }
}

tagName Example in Python

from selenium import webdriver
from selenium.webdriver.common.by import By

# Step 1: Launch browser
driver = webdriver.Chrome()

# Step 2: Open a website
driver.get("https://example.com")

# Step 3: Find a single element by tag name
first_paragraph = driver.find_element(By.TAG_NAME, "p")
print("First paragraph text:", first_paragraph.text)

# Step 4: Find multiple elements by tag name
all_links = driver.find_elements(By.TAG_NAME, "a")
print("Total links found:", len(all_links))

# Step 5: Close browser
driver.quit()

C# Example

using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using System;
using System.Collections.ObjectModel;

class TagNameExample
{
    static void Main()
    {
        // Step 1: Launch browser
        IWebDriver driver = new ChromeDriver();

        // Step 2: Open a website
        driver.Navigate().GoToUrl("https://example.com");

        // Step 3: Find a single element by tag name
        IWebElement firstParagraph = driver.FindElement(By.TagName("p"));
        Console.WriteLine("First paragraph text: " + firstParagraph.Text);

        // Step 4: Find multiple elements by tag name
        ReadOnlyCollection<IWebElement> allLinks = driver.FindElements(By.TagName("a"));
        Console.WriteLine("Total links found: " + allLinks.Count);

        // Step 5: Close browser
        driver.Quit();
    }
}

Advantages of the tagName locator

Here is a list of advantages of using tagName in your Selenium test.

Simple and Easy to Use

It is straightforward to locate elements by their HTML tag, like a, div, table, etc

Useful for Bulk Element Retrieval

Handy to collections of elements with the same tag name, like:

All links on a page (<a>)
All rows in a table (<tr>)
All images (<img>)

Efficient for Common Scenarios

You can use the tag name locator when you are looking to loop through lists of similar elements, or iterate over table rows or cells.

No Need for Attributes

Other locators like ID, name, Class name need an attribute and a value. But you just need an HTML tag to locate an element by tag name.

Lightweight Selector

It is a lightweight selector compared to XPath and CSS selectors.

Limitations of TagName Locator

Each and every locator has its own strength and limitations. Same way, finding by tagName has its own limitations as below.

Not Specific Enough

Common tags like div, span, and a can appear many times, so findElement() will return only the first matching element. Also, it is hard to target specific elements without combining it with other locators.

Limited Filtering

Using tagName, direct filtering by attributes like id, class, name is not possible.

Can Return Empty Results

findElements() will return an empty list and findElement() will throw a NoSuchElementException if the tag is not present on the page.

May Impact Performance

If there are lots of matching tags on the same page, it is not advised to use tagName as a locator. It can impact performance.

Frequently Asked Questions (FAQs)

Question: What is By.tagName() in Selenium?

Answer: By.tagName() is an element locator strategy that is used to find web elements by their HTML tag name.

Question: When should I use By.tagName()?

Answer: You can use it when

You want to find all elements of a certain type (e.g., all links <a>, all images <img>).
You are working with tables (e.g., rows <tr>, cells <td>).
There’s no unique attribute like ID or Class available.

Question: Can I use By.tagName() to locate multiple elements?

Answer: Yes! You can use findElements(By.tagName("tagname")) to retrieve a list of elements.

Question: What happens if no element is found by tagName()?

Answer:

findElement(By.tagName()) will throw a NoSuchElementException.
findElements(By.tagName()) will return an empty list/collection.

Question: How is By.tagName() different from other locators like By.id() or By.className()?

Answer:

By.tagName() will search by the HTML tag and not by the attributes.
It will return many elements, whereas By.id() or By.name() usually return unique elements.

Question: Is By.tagName() case-sensitive?

Answer: No. HTML tag names are not case-sensitive, but it is advised to use lowercase (e.g., "div", "a").

Question: What are some common tags I can use with By.tagName()?

Answer: You can use the following tags:

a → links
img → images
div → containers
span → inline elements
p → paragraphs
table, tr, td → tables
h1, h2, etc. → headings
input, button → form elements

Common Errors & Troubleshooting

Error: NoSuchElementException

Fix: It happens when Selenium is unable to find the element by your provided tag name. Make sure the element is available in the DOM and it is visible when Selenium is searching for it.

Error: Incorrect Tag Name

Fix: This happens when you use the wrong casing or add typos in the tag name. Always use correct tag name in lower case.

Error: ElementNotVisibleException / ElementClickInterceptedException

Fix: This error occurs when an element is not visible or covered by another element. You can use WebDriverWait to make sure it is visible before interaction.

Error: StaleElementReferenceException

Fix: This error occurs when Dom is updated. To fix this issue, re-locate the element after DOM update.

Best Practices

Use TagName for Groups: Finding element by tagName is best to find multiple similar elements.
Narrow the Search Scope: To interact with a child element, first locate the parent element and then use tagName inside them to avoid unwanted matches.
Always Use Lowercase Tags: Use tag name in lower case to reduce unwanted errors.
Handle Empty Lists: When using findElements(), check for empty list before performing actions.
Switch to Frames/Windows: If you are working with multiple frames or windows, first of all, switch focus on them before performing any action.

tagName is a very useful locator in Selenium if used in correct scenarios.

Have any questions or queries? You can ask me in a comment below. I will try my best to answer you.

Find Element by Class in Selenium: Complete Guide for Beginners (Best Practices, FAQs)

noreply@blogger.com (Unknown) — Sun, 09 Mar 2025 07:02:00 +0000

Selenium is a flexible automation testing tool that provides multiple ways to locate web elements. findElement(By.className()) is one of the different types of element locators in Selenium. You can use this method in Selenium when an element has a class attribute. It allows you to select a group of elements or a specific element. You can use it to identify web elements like buttons, links, or input fields.

In this guide, we will learn about:

What findElement(By.className()) is
Why Use Find Element by Class In Selenium?
How to Use findElement(By.className())
Limitations & Advantages
Examples in Java, Python, and C#
Find element by class FAQs
Troubleshooting Common find element by class Errors

What is findElement(By.className())?

className() is a method in the By class. It helps to find elements using their CSS class name.

It returns a ByClassName object, which internally converts the class name into a CSS selector (.classname).

This makes it easier for Selenium to locate elements on a webpage using class name.

In Selenium WebDriver, one can use findElement(By.className()) method to locate an element based on its class name attribute.

If multiple elements have the same class name, then Selenium will return the first matching element by default.

Why Use Find Element by Class In Selenium?

There are multiple reasons to use find element by class.

Simple and Efficient:

Class names are used in HTML to group similar elements like buttons, links, or sections. So it is a straightforward way to find an element by its class.

Common in Web Design:

Generally similar elements are styled together using a class name. So you can easily target all those elements using By.className().

Example:

<button class="submit-button">Submit</button>

<button class="submit-button">Cancel</button>

In the above example, both buttons have the same class name submit-button. So you can easily target both of them using findElement(By.className("submit-button"))

Readable and Easy to Maintain:

If a class name is descriptive like login-button, error-message, or product-card, and you use it in selenium tests, then it will be easy for other developers and testers to read and understand it.

When Other Selectors Are Less Reliable

Sometimes other locators like By.id(), By.name(), or By.xpath() are not working. In that case, using class name locator is more reliable.

Java Syntax

WebElement element = driver.findElement(By.className("your-class-name"));

Python Syntax

element = driver.find_element(By.CLASS_NAME, "your-class-name")

C# Syntax

IWebElement element = driver.FindElement(By.ClassName("your-class-name"));

Using class name in XPath

To find an element by class name attribute in Python, you can use XPath as below.

element = driver.find_element(By.XPATH, '//*[@class="class_name"]')

Here is an example to locate an element by class and ID attributes in Python selenium test script.

element = driver.find_element(By.XPATH, '//*[@id="element_id" and contains(@class, "class_name")]')

To find an element by class and name attribute in Python, you can use XPath as below.

element = driver.find_element(By.XPATH, '//*[@name="element_name" and contains(@class, "class_name")]')

You can use the below given XPath syntax in Python to locate an element using class name and text.

element = driver.find_element(By.XPATH, '//*[contains(@class, "class_name") and text()="Exact Text"]')T

How to Use findElement(By.className())

Here is a step-by-step guide to find an element using the class name.

Step 1: Get the class name of an element?

To use it, you need the class name of the element before using it in the Selenium test.

To get the class name of web element:

Right click on element.
Select inspect element.
From the inspect element window, you will get a class name as shown in the below image.

Step 2: Get your test page URL

Copy the URL of the test page you are looking to test in Selenium test.

Step 3: Launch your IDE

Launch IDE as per your programming language, you use for Selenium Testing, i.e. IDLE, Visual Studio, or Eclipse.

Step 4: Create project and add selenium dependencies

To run Selenium tests, you need to create a project and add the required Selenium Jars to run Selenium tests in it. Also, you need to update your Chrome browser and download the latest chromedriver and configure it in your system.

Step 5: Run test

Here are examples of how to use find element by class in Java, Python, and C# languages.

You need to update test page URLs and class name in the following examples before running the test.

Java Example

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

public class FindByClass {
    public static void main(String[] args) {
        System.setProperty("webdriver.chrome.driver", "path/to/chromedriver");
        WebDriver driver = new ChromeDriver();
        driver.get("https://example.com");

        WebElement element = driver.findElement(By.className("example-class"));
        System.out.println("Element text: " + element.getText());

        driver.quit();
    }
}

Python Example

from selenium import webdriver
from selenium.webdriver.common.by import By

# Initialize WebDriver
driver = webdriver.Chrome()
driver.get("https://example.com")

# Locate element by class name
element = driver.find_element(By.CLASS_NAME, "example-class")
print("Element text:", element.text)

# Close browser
driver.quit()

C# Example

using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using System;

class FindByClassName
{
    static void Main()
    {
        IWebDriver driver = new ChromeDriver();
        driver.Navigate().GoToUrl("https://example.com");

        IWebElement element = driver.FindElement(By.ClassName("example-class"));
        Console.WriteLine("Element text: " + element.Text);

        driver.Quit();
    }
}

Limitations:

Works only with single-class names: Selenium does not support multiple class names. If the class attribute has multiple class names like <div class="class1 class2">.
Returns only the first matching element: If you are looking to get all elements with the same class, use findElements(By.className()) instead.
Not recommended for dynamically generated class names: If the class name changes on every page reload, it is recommended to not use it in selenium test scripts.

Advantages:

Faster than Other Methods in Some Cases: Searching by class name will be faster if multiple elements have the same tag but different attributes.
No Need for Complex Selectors: Unlike other complex selectors like XPath or CSS, find by class name is simple. It does not require extra syntax or logic to identify the element.
Works Well for Elements with Distinct Classes: This method will directly return the target element, if elements have a clear and unique class name.
Avoids XPath Limitations: Sometimes XPath struggles with complex queries. Using class name will provide a simpler and more robust solution.

Frequently Asked Questions (FAQs)

Question: What is finding element by class name in Selenium?

Answer: findElement(By.className()) is a Selenium WebDriver method that is used to locate an element using its class name.

Question: How do I find an element by class name in Selenium?

Answer: You can use the following syntax

driver.find_element(By.CLASS_NAME, "your_class_name")

Question: What is the difference between findElement(By.className()) and findElements(By.className())?

Answer:

findElement(By.className()) returns the first matching class element.
findElements(By.className()) returns a list of all matching class elements.

Question: Can I use multiple class names in findElement(By.className())?

Answer: No, Selenium does not support compound class names. You can use CSS selector instead like:

driver.find_element(By.CSS_SELECTOR, ".classx.classy")

Question: Why is find_element_by_class_name deprecated?

Answer: Selenium 4 removed find_element_by_class_name. Now, you can use driver.find_element(By.CLASS_NAME, "your_class_name").

Question: How do I click an element found by class name?

Answer: After finding the element, use: element.click() in your selenium test.

Question: How do I get text from an element found by class name?

Answer: Use given syntax below to get text:

text = driver.find_element(By.CLASS_NAME, "your_class_name").text

Question: Can I use findElement(By.className()) for hidden elements?

Answer: No, Selenium cannot interact with hidden elements.

Question: How do I check if an element exists before finding it?

Answer: You can use the following syntax:

elements = driver.find_elements(By.CLASS_NAME, "your_class_name")
if elements:
    print("Element found!")

Question: What’s the best alternative if find element by class name fails?

Answer: CSS_SELECTOR is the best alternative.

Question: Can I use regex with find element by class name?

Answer: No, but you can use XPATH with contains():

driver.find_element(By.XPATH, "//*[contains(@class, 'partial_class_name')]")

Troubleshooting Common find element by class Errors

Error: ❌ NoSuchElementException: Unable to locate element.

Fix: ✅ You need to check the following things to resolve this error.

Make sure element exists on the page.
Check if the class name is correct (case-sensitive).
Wait for the element to load using WebDriverWait.

Error: ❌ InvalidSelectorException: Compound class names not permitted.

Fix: ✅ You will get this error when you try to locate an element using findElement(By.className()) and the element has multiple class names i.e. <div class="class1 class2">.

To fix this error, you can use an alternative element locator like CSS Selector. Example:

driver.find_element(By.CSS_SELECTOR, ".class1.class2")

Error: ❌ StaleElementReferenceException: Stale element reference

Fix: ✅ This error occurs when an element is no longer attached to the DOM.

To fix this:

Re-locate the element before interacting with it.
Use WebDriverWait with EC.staleness_of(element).

Error: ❌ AttributeError: 'WebDriver' object has no attribute 'find_element_by_class_name'.

Fix: ✅ Actually, find_element_by_class_name is deprecated in Selenium 4.

Now in Selenium 4, you can use:

driver.find_element(By.CLASS_NAME, "class_name")

Error: ❌ ElementClickInterceptedException

Fix: ✅ This error occurs when another element is blocking the target element.

To resolve this issue, you can use JavaScriptExecutor to force-click:

driver.execute_script("arguments[0].click();", element)

Error: ❌ TimeoutException: element not found within time.

Fix: ✅ This error occurs when an element is taking time to load.

To fix this error, use WebDriverWait to wait until it appears:

from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC  

WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.CLASS_NAME, "class_name")))

Error: ❌ TypeError: find_element_by_class_name() missing 1 required positional argument

Fix: ✅ This error occurs when you pass class name incorrectly. Pass the class name correctly:

driver.find_element(By.CLASS_NAME, "your_class_name")

Error: ❌ Multiple elements found when expecting a single element.

Fix: ✅ This error occurs when you use driver.find_element and return multiple elements. In this case, you can use driver.find_elements in Selenium 4.

driver.find_elements(By.CLASS_NAME, "your_class_name")

Error: ❌ NoneType object has no attribute 'click'

Fix: ✅ Targeted element was not found, so it returned None. In this case, you need to verify the class name or add an explicit wait before interacting with the element.

Error: ❌ find_element(By.class_name) works in one browser but not another.

Fix: ✅ Different browsers render elements differently. If the find element by class name is not working in a specific browser, then you can try CSS_SELECTOR or XPATH as an alternative.

Best Practices for Find By Class

Here are a few important points you need to consider while using Find By Class in Selenium WebDriver automation test.

Prefer selecting elements with unique class names to avoid ambiguity.
Prefer Selenium 4 Syntax (By.CLASS_NAME)
Always use explicit waits to handle dynamic elements.
Use CSS_SELECTOR or XPATH for more reliable selection.
Check for hidden elements before interacting.
Print logs when elements are found or actions are taken for easy debugging.
Make sure that page is fully loaded before interacting with the element.

Pro Tip: If you often struggle with class selectors, consider using CSS_SELECTOR or XPATH especially for complex DOM structures.

Now you’re all set to use find by class in Selenium tests without errors!

Have any questions? Drop a comment below! I am ready to help you with.

How to download chromedriver for selenium (Step-by-Step Guide)

noreply@blogger.com (Unknown) — Sun, 09 Mar 2025 04:28:00 +0000

Are you looking to automate tests with Selenium but can’t get the correct version of ChromeDriver? You’re not alone.

Many testers and developers are struggling with errors like:

❌ SessionNotCreatedException: This version of ChromeDriver only supports Chrome version X

❌ chromedriver executable needs to be in PATH

Here is the solution.

This article will teach you how to download, install, and set up ChromeDriver for Selenium in Windows, Linux, and MAC OS (without errors).

Step 1: Check Your Chrome Version

It is necessary to check your Chrome version before downloading chromedriver.

How to Check Chrome Version

There are two methods to check the Chrome browser version.

Method 1:

Open Google Chrome.
Type chrome://settings/help in the address bar.
Look for the Version Number (e.g., My current chrome browser version: 134.0.6998.89)

Method 2:

Click on the three dots at the top-right corner of Chrome browser. It will open the menu.

Select setting from the menu.

It will open the Chrome settings page.

On the settings page, you will find the About Chrome menu at the bottom-left corner.

Click on it.

On the About Chrome page, you can see your Chrome browser's version as shown in a given image.

Why does this matter?

Because ChromeDriver must match your Chrome version. If they do not match, you might get an error when executing your Selenium test.

Tips: Always use the latest version of Google Chrome and a latest stable release version of Chromedriver to minimize errors.

Update on Latest stable version release: Version 134.0.6998.88 of ChromeDriver and Chrome browsers are available to download.

Learn a detailed guide on what is WebDriver in Selenium.

Step 2: Download the Correct ChromeDriver

Now, let’s download the right version of ChromeDriver.

Find the ChromeDriver version that matches your Chrome browser and OS, and download the right file for your system:

Go to Official ChromeDriver Download Page to get direct download link.
Navigate to Stable version section.

Choose your OS:

Windows: chromedriver-win64.zip
Mac (Intel or ARM): chromedriver-mac-x64.zip / chromedriver-mac-arm64.zip
Linux: chromedriver-linux64.zip

Copy URL from the table as per your OS and Chrome browser's version and open it in the browser.

It will download the Zip file.

Once downloaded, extract the ZIP file to get the chromedriver executable.

Open extracted folder. You will get the chromedriver.exe (Executable file) file inside it.

Tip: Store chromedriver in a folder from where you can access it easily, like D:/chromedriver/

Step 3: Install and Set Up ChromeDriver in Selenium

Now that you have ChromeDriver, but Selenium doesn't know where it is. You need to tell Selenium where to find it.

There are two options.

Option 1: Set Chromedriver Path in Environment Variable

Search for Edit the system environment variables from Windows search.
Click on Environment Variable button from Advanced tab.
Select Path from System Variables section and click on Edit button.
Click on the New button and set Chromedriver Path as shown in the image below and click OK.

That's it.

Option 2: Specify ChromeDriver Path in Code

If you don’t want to modify system settings, you can also manually set the path in Selenium code. Here is an example:

        System.setProperty("webdriver.chrome.driver", "D:\\chromedriver.exe");
	WebDriver driver= new ChromeDriver();		
        driver.get("https://only-testing-blog.blogspot.com/");

Note: Replace "D:\\chromedriver.exe" with the path where you extracted ChromeDriver.

The Easy Way – Use WebDriver Manager

It is annoying to download ChromeDriver and all other drivers manually every time the browser version updates. Instead of manually downloading ChromeDriver, let WebDriver Manager handle everything:

Here’s a way:

Install WebDriver Manager in Eclipse

If you are using Java with Eclipse, you can create a Maven Project and add WebDriver Manager Dependencies in the pom.xml file:

Install Maven in Eclipse
Create a Maven project in Eclipse.
Get the latest webdrivermanager dependency from MVN Repository.
Add the webdrivermanager dependency in the pom.xml file.

Now, you can use WebDriver Manager in your Selenium tests.

    // Automatically download and setup ChromeDriver
    WebDriverManager.chromedriver().setup();
        
    // Launch Chrome browser
    WebDriver driver = new ChromeDriver();

Downloading Older/Previous Versions of ChromeDriver

Note: It is not recommended to use older versions of ChromeDriver.

Recently I was looking to download the previous version of ChromeDriver to verify browser compatibility for one of our under development websites.

I found a reliable source to download older versions of ChromeDriver after 2+ hours of Google search. So I thought, let me share it with all of you guys.

When you open that page, it contains direct download URLs of ChromeDriver for all previous version releases.

Example: If you are looking to download chromedriver 131.0.6724.0, you will find a URL like below on that page. You can open it in your browser to start download.

https://storage.googleapis.com/chrome-for-testing-public/131.0.6724.0/win64/chromedriver-win64.zip

Similarly, you will find separate ChromeDriver download URLs for all older versions like 128, 129, 130, etc, for Linux, macOS, and Windows.

Common Errors and Fix

Error: SessionNotCreatedException – ChromeDriver version mismatch

Fix: Download the correct ChromeDriver version matching your Chrome browser.

Error: chromedriver executable needs to be in the PATH

Fix: Add ChromeDriver to the system PATH or specify its full path in your code.

Error: selenium.common.exceptions.WebDriverException

Fix: Update ChromeDriver or use WebDriver Manager.

Frequently Asked Questions (FAQs)

Question: Where can I download the latest ChromeDriver?

Answer: You can download the latest ChromeDriver from the official Google ChromeDriver website: https://googlechromelabs.github.io/chrome-for-testing/

Question: How do I check my Chrome version?

Answer: Go to chrome://settings/help, and your Chrome version will be displayed.

Question: How do I fix the "ChromeDriver executable needs to be in PATH" error?

Answer: Either add ChromeDriver to your system environment variable PATH or specify its full path in your Selenium script.

Question: What is the easiest way to install ChromeDriver?

Answer: Use WebDriver Manager. It will automatically download and update ChromeDriver.

Question: How to fix ChromeDriver version mismatch?

Answer: The ChromeDriver version mismatch error occurs when a version of ChromeDriver and your Chrome browser do not match. To resolve this ChromeDriver compatibility error, follow these steps.

Check Your Chrome Browser Version: Go to Chrome browser's help section and check version. Update version if using older one.
Download the Matching ChromeDriver Version: Go to the official Chrome driver download page as discussed earlier in this article. Download latest version.
Update ChromeDriver in Your Project: Update the latest downloaded Chrome driver executable file in your project.

Question: What should I do if ChromeDriver keeps crashing or does not launch Chrome?

Answer: To fix this issue, update your Chrome browser and chromedriver to the latest stable version. Also, check if you are using any browser extension that conflicts with the current version.

Question: How do I run ChromeDriver with a specific user profile?

Answer: Use the --user-data-dir argument in Chrome options.

Question: How to check installed version of Chrome driver?

Answer: Steps to check Chrome driver version,

Open the Command Prompt (Windows) or Terminal (Mac/Linux).
Type command: chromedriver --version.
Press Enter.

Command prompt will display installed ChromeDriver version number.

Now you’re all set to run Selenium tests without errors!

Have any issues? Drop a comment below!

Name Locator in Selenium: A Complete Guide (Advantages, Limitations, Syntax, Examples, and Alternatives)

noreply@blogger.com (Unknown) — Sat, 08 Mar 2025 05:54:00 +0000

Selenium WebDriver supports many types of element locators like ID, Name, TagName, Class, XPath, and CSS Selectors to find and interact with the web element on a page. One of them is the Name locator. You can use the By.name() method to identify the element using the name attribute of the element. This guide will help you to learn how to use the Name Locator in Selenium, its advantages, limitations, and best practices.

What is Name Locator in Selenium?

It is an element locating strategy in Selenium WebDriver. It is used to find elements based on the value of their name attribute. If Selenium finds multiple elements with the same name, it will select the first matching element by default.

Syntax: WebElement element = driver.findElement(By.name("element_name"));

Why Use Name Locator?

There are a couple of advantages and disadvantages of using it in Selenium WebDriver. Let's look at both of them one by one.

Advantages:

Simple and Readable: It is easy to use in Selenium test script. Also, it helps to improve code readability as a name often describes the function or purpose of the element.
Faster Execution: Searching an element by Name attribute is faster than XPath element locator.
Works Well in All Major Browsers: No browser compatibility issues.
Stable: Generally, it is stable as its value does not change like the ID attribute.

Limitations:

Not Unique Always: There are chances of multiple elements having the same name attribute value. In that case, Selenium will pick the first occurrence.
Dynamic Changes: If the value of the name attribute changes frequently, Locator will become unreliable.
Limited Coverage: You may not find the Name attribute for all elements. In such cases, you need to use other locators like find element by ID, Class, write XPath, or CSS.

Is the Name Locator Faster than Other Element Locators?

Answer is Yes and No both. It is slower than ID locator, but it is faster than XPath and CSS Selector. Also, it depends on the web page structure. It performs better on the well-structured page.

Why it is Faster Than XPath and CSS Selectors?

Here are a few reasons why we can say it is faster.

Direct Attribute Access: It is faster than complex XPath or CSS queries because the Name locator (By.name("elementName")) can directly access the element’s name attribute.
Index-Based Searching: Generally, browsers optimize search for the name attribute. So it is possible to quickly look up a specific attribute instead of traversing the entire DOM.

When is Name Locator Slower?

Here are the scenarios when it is slower.

If multiple elements have the same name attribute, Selenium may have to filter through them. That makes it slower than the ID locator.
If the name attribute is not unique, Selenium will return a list of elements. It requires additional filtering.
In many modern web applications, I have seen that elements are generated dynamically. In such cases, the name attribute may be missing for the element.

In summary, it is slower than ID locator, but it is faster than className, CSS Selector, and XPath locators.

For better performance, you should use ID locator (If it is present and stable) instead of Name. But if ID is not present, then name selector is a better choice compared to other locators like CSS and XPath.

How to get the name attribute of an element?

To get the name attribute of an element, I am using two methods.

Right click on element and select Inspect element option. It will open the HTML structure of the element in a window. You can copy the name attribute from this window.
I am using SelectorsHub element locator. Right click on element, navigate to SelectorsHub option and click Copy Name.

Syntax of Name Locator

Syntax in most popular programming languages like Java, Python, and C# is given below.

Syntax in Java:

WebElement element = driver.findElement(By.name("element_name"));

Syntax in Python:

element = driver.find_element(By.NAME, "element_name")

Syntax in C#:

IWebElement element = driver.FindElement(By.Name("element_name"));

Examples of How to Use Name Locator in Selenium

Now let us look at some real-world and practical examples of using this locator in Selenium.

Example 1: Locate an Input Field by Name

Consider a form with an input field for a user's name. Here's how you can identify an input element by name and type value in it.

HTML Code

<input type="text" name="username" />

Selenium Code (Java):

WebElement usernameField = driver.findElement(By.name("username"));
usernameField.sendKeys("TestUserName");

Example 2: Click a Button by Name

Locate a button using Name locator and click on it.

HTML Code:

<button type="submit" name="submitButton">Submit</button>

Selenium Code (Python):

submit_button = driver.find_element(By.NAME, "submitButton")
submit_button.click()

Also, it is possible to write XPath using the name attribute.

Here is an example for the submit button.

//button[@name='submitButton']

Example 3: Select a Radio Button by Name

You can use the Name locator to select a specific option from radio buttons.

<input type="radio" name="gender" value="male" /> Male
<input type="radio" name="gender" value="female" /> Female

Selenium Code (C#):

IWebElement maleOption = driver.FindElement(By.Name("gender"));
maleOption.Click();

How to Handle Multiple Elements with Same Name?

If multiple elements have the same name, and it is only a choice, then you can use the findElements() method and select the element based on index.

Here is an example of how to click on the second element when multiple elements are found with the same name attributes.

List<WebElement> radioButtons = driver.findElements(By.name("age"));
radioButtons.get(1).click(); // Clicks the second radio button

Best Practices

You should follow these guidelines when using the Name selector.

Ensure Uniqueness: Make sure the Name attribute you are using is unique on the page.
Combine with Other Locators: To make it robust and if it is necessary, combine it with other locators like CSS Selectors or XPath.
Avoid Hardcoding: If the value of Name is changing frequently, it is advisable to use a dynamic strategy.
Don’t Rely Exclusively on Name: In some cases, the ID or class attribute might be better for more accuracy.

Alternative Locators in Selenium

If you find Name Locator isn't reliable, you can consider using the following locators instead.

ID Locator – By.id("element_id")
Class Name Locator – By.className("class_name")
CSS Selector – By.cssSelector("css_expression")
XPath – By.xpath("xpath_expression")

Name is one of the powerful element locators in Selenium, especially when dealing with forms and input elements. It is simple, stable, and easy to use in Selenium test scripts. However, like other locators, it has some limitations and disadvantages. If you have proper knowledge of when to and how to use it, you can write better automation tests using it. No matter if you are new to Selenium or a seasoned professional.

Find Element by ID in Selenium: A Complete Guide with Examples

noreply@blogger.com (Unknown) — Fri, 07 Mar 2025 11:58:00 +0000

Locating element is a crucial part in Selenium automation testing. There are many element locators available in Selenium, but finding an element by ID is one of the most reliable and most expert-recommended methods.

Why Use ID to Locate Elements?

There are many different element locators available in Selenium. But why should you prefer ID? Here are reasons.

Unique Identifier: Generally, ID is unique on the page. That makes it most reliable to use it in the Selenium test scripts.
Faster Execution: It is the quickest and fastest way to find an element from the page compared to other locators like XPath or CSS selectors.
Improved Stability: There are fewer chances of changing ID in the future. It will reduce your maintenance effort in test scripts.
Supported in All Browsers: Works well in all major browsers without any compatibility issues.

Now let us see why ID is faster than other element locators.

Why is finding an element by ID the fastest element locator strategy?

There are multiple reasons as below.

Direct Mapping in the DOM: Finding an element by ID is the fastest element locator strategy because browsers have an optimized lookup mechanism to find elements by ID instantly.
Optimized Browser API: Also, Selenium is using browser's native getElementById() method, which is highly optimized for performance.
No Complex Query Processing: No need to search in the entire DOM tree like XPath locator and CSS selectors. findElement(By.id()) retrieves the element in constant time.
Minimal Resource Consumption: Since IDs are unique, the search stops as soon as the element is found.

Always prefer to use ID as an element locator if an element has a unique ID.

How to Find ID of element from web page?

You need actual ID of the element to use it in the Selenium test script. There are multiple ways to find the ID of the element. But you can use any of the following ways that I am using to get an element's ID easily.

Using Inspect Element: Right click on Element -> Select Inspect. In the inspect element window, you will get the ID of the element.
Using SelectorsHub Plugin: Install SelectorsHub extension -> Right click on element -> Navigate to SelectorsHub -> and Select Copy ID. It will copy the ID of the element.

Syntax to Find Element by ID in Selenium

Here are examples to find an element by ID in Selenium Python, Java, and C#. Well, there is no language dependency in finding an element by ID. But for better understanding, I have provided an example in all the popular three languages used with Selenium WebDriver.

Python Example to Find Element by ID

from selenium import webdriver
from selenium.webdriver.common.by import By

# Initialize WebDriver
driver = webdriver.Chrome()

# Open a webpage
driver.get("https://example.com")

# Find element by ID
element = driver.find_element(By.ID, "id_of_element")

# Perform action
element.click()

# Close the browser
driver.quit()

Java Example to Find Element by ID

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

public class FindByIdExample {
    public static void main(String[] args) {
        // Set up WebDriver
        WebDriver driver = new ChromeDriver();
        
        // Open webpage
        driver.get("https://example.com");
        
        // Find element by ID
        WebElement element = driver.findElement(By.id("id_of_element"));
        
        // Perform action
        element.click();
        
        // Close browser
        driver.quit();
    }

C# Example to Find Element by ID

from selenium import webdriver
from selenium.webdriver.common.by import By

# Initialize WebDriver
driver = webdriver.Chrome()

# Open a webpage
driver.get("https://example.com")

# Find element by ID
element = driver.find_element(By.ID, "id_of_element")

# Perform action
element.click()

# Close the browser
driver.quit()

Handling NoSuchElementException

For best practices, it is essential to handle NoSuchElementException if Selenium is unable to find an element located by ID. You can include a try catch block as provided in the following examples.

Handling NoSuchElementException in Python

from selenium.common.exceptions import NoSuchElementException

try:
    element = driver.find_element(By.ID, "wrong_id_of_element")
except NoSuchElementException:
    print("Element not found!")

Handling NoSuchElementException in Java

import org.openqa.selenium.NoSuchElementException;

try {
    WebElement element = driver.findElement(By.id("wrong_id_of_element"));
} catch (NoSuchElementException e) {
    System.out.println("Element not found!");
}

Handling NoSuchElementException in C#

using OpenQA.Selenium;
using OpenQA.Selenium.NoSuchElementException;

try
{
    IWebElement element = driver.FindElement(By.Id("wrong_id_of_element"));
}
catch (NoSuchElementException)
{
    Console.WriteLine("Element not found!");
}

Also, you can use an element's ID in XPath like //input[@id='FName'] to find an element by attribute ID in XPath with Selenium.

This way, you can handle NoSuchElementException in Selenium WebDriver if it is unable to find an element by ID.

Alternatives of Find Element By ID

Find element by ID is the best choice if the element has a unique and stable ID. But it is possible that the element you are trying to locate does not have an ID attribute. In this case, you can consider using other attributes like

If your element contains a link (text inside <a> elements), then you can use

Link Text (By.LINK_TEXT)
Partial Link Text (By.PARTIAL_LINK_TEXT)

Using Explicit Waits for Better Stability

If the element or page is taking a longer time to load, then it is recommended to use explicit wait to reduce unnecessary errors.

Here is an example of an explicit wait

from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# Wait until the element is present
element = WebDriverWait(driver, 10).until(
    EC.presence_of_element_located((By.ID, "element_id"))
)
element.click()

It will explicitly wait for 10 seconds if unable to locate the element by ID while you run the Selenium test.

Common Errors and Troubleshooting Tips

ElementNotVisibleException: That means, the element is present on the page but not visible to Selenium. You can try using explicit waits.
StaleElementReferenceException: This exception occurs when an element is no longer valid. You can retry to locate it again.
InvalidSelectorException: Check if the selector syntax is incorrect.

Best Practices

For best practices, you must consider these points while using find element by ID.

Make sure the ID is unique on the page. It will help to avoid wrong element selection.
Do not hesitate to use explicit waits if elements take time to load.
Use logging to debug test failures effectively.
Avoid using dynamically changing IDs in the test script. Such IDs can break the test scripts.
If the element's ID is changing dynamically, and ID is the only choice, then you can use ID in XPath with contains(), starts-with(), or ends-with() functions. It will help you to match partial attribute value. You can refer to this XPath in Selenium tutorial where I mentioned how to handle dynamic changing ID in XPath.

Using find element by ID is one of the best, convenient, and efficient element locator strategies. It is fast, reliable, and easy to use. By following these best practices, you can improve the stability of your test automation.

Still have any questions? You can ask me in the comment.

How to write and Use XPath in Selenium (Using attributes, Axes, operators, functions)

noreply@blogger.com (Unknown) — Fri, 07 Mar 2025 05:10:00 +0000

One of the main reasons behind Selenium's popularity is that it supports multiple element locators. And one of them is XPath. XPath is one of the most powerful and flexible element locators in Selenium Webdriver. It helps you to navigate through the HTML structures of a page to locate an element using XPath.

In this guide, we will learn about what is XPath, how it works, and when to use it in Selenium test scripts. It is necessary to learn about different ways to find XPath of the element and how to write XPath syntax easily using real world examples. By the end, you will know the difference between absolute vs. relative XPath, common XPath expressions, and how to handle dynamic and nested elements like a pro.

What is XPath in Selenium?

Just like you use GPS to locate your car, XPath(XML Path Language) is used to locate an element on a webpage. It helps Selenium WebDriver testers to navigate through a webpage’s structure to find the exact element they need. No matter in which language you are working, the Same XPath will work in Java, Python, C#, and JavaScript languages.

When to use XPath In Selenium WebDriver?

Just recently, one of my colleagues was trying to locate an element by ID, but it was changing on page reloads. Then he tried to locate it by class name, but there was no unique class name of the element. Also, there was no option to locate element by name, tag name, etc. In such a scenario, the only way to locate the element is by XPath.

You can use XPath element locator:

When dealing with dynamic elements that change frequently.
When you need to navigate between elements (like finding a button inside a specific div).
When other locators don’t work or aren’t stable.
When working with complex web structures like SVG or Shadow DOM.

When not to use XPath in Selenium?

While XPath is a powerful locator, it’s not always the best choice. Here are some situations where you should avoid using XPath and opt for better alternatives.

When performance is important → XPath is the slowest option.
When an element has a unique and stable ID or Name. → Use By.id() to By.name().
When CSS Selectors can do the job → Use By.cssSelector()
When dealing with Shadow DOM → It is better to use JavaScript instead of XPath.
When working with SVG Elements → CSS Selectors is a better option.

Why Should You Use XPath?

If you are working with Selenium WebDriver automation, you have definitely heard about XPath. But do you know why to use XPath over other element locators like ID, Name, or CSS Selectors? Let us break it down in simple words.

XPath Can Find Any Element on the Page

Think of XPath as a GPS for your web page. It can find an element even if it is buried in the DOM (Document Object Model). When other locators fail, XPath will work perfectly in your test.

Great for Dynamic and Complex Elements

In modern websites, you might have seen that elements are generated on the fly. Meaning their IDs or classes change constantly. To locate such elements, you can build an XPath using flexible expressions instead of relying on static attributes.

You Can Move Around the DOM Like a Pro

Using XPath, one can navigate between elements. It is easy to find a parent, child, or sibling element. When elements do not have unique attributes, this is a super handy way to locate an element by referencing another nearby element.

Absolute vs. Relative XPath

Absolute XPath (/html/body/div/input) is like providing a full direction from the beginning of the page. It is precise, but fragile (one small change can break your XPath).

Relative XPath (//input[@type='text']) is a more flexible way to locate an element based on its attributes, no matter where they are on the page.

Powerful Search Functions

XPath has built-in search functions like contains(), starts-with(), and text(). It makes it easier to find an element on the web page.

Example:

contains(): //button[contains(text(),'Submit')]: Finds buttons with "Submit" in the text.

starts-with(): //button[starts-with(@class,'drop')]: Finds input textbox elements where the class value starts with "drop" text.

text(): //h1[text()='Hello']: Finds an element with exact text "Hello".

Handles Shadow DOM & SVG Elements

It is hard or impossible to locate elements like SVG graphics or Shadow DOM elements using other element locators. But you can access such elements easily using XPath.

Combine Multiple Conditions for Precision

Are you looking to find a specific input field? You can combine conditions like this to find an element using multiple conditions. Example: //input[@type='text' and @name='username'].

What are the different types of XPath?

Mainly there are two types of XPath that you can use in Selenium. Absolute XPath and Relative XPath. Each type has its own use case, advantages, and limitations. As experts suggest, Relative XPath is more reliable than the Absolute XPath.

Let’s go through them step by step to learn how to build XPath with examples.

Absolute XPath (Avoid If Possible!)

Absolute XPath Provides exact path from the root <html> tag to your element. But it can break if page structure changes.

It is just like giving a direction to someone like "Go to the first building, enter the second room, then open the first drawer."

Example of Absolute XPath:

/html/body/div[1]/form/input

It will locate the input element which is present on the given full path.

Pros and Cons of Absolute XPath

Pros of Absolute XPath:

Precise: Points directly to your targeted element.
Easy to generate: You can easily copy it from your browser's dev tool.

Cons of Absolute XPath:

Easily breaks: It can break even if there is a small change in page structure.
Hard to maintain: You need to update the XPath even a small update on the page.
When to use?: Only as a last resort when nothing else works.

Relative XPath (The Smart Choice!)

Relative XPath can find an element from anywhere in the DOM. It does not follow the strict path, but looks for the element based on its properties.

Example of Relative XPath

//input[@id='username']

It will locate the <input> field with the ID username from anywhere on the page.

Pros of Relative XPath

More flexible: It works even if the structure of the page changes.
Easier to maintain: Doesn’t break with minor updates.
More readable: You can locate elements by attributes, text, or relationships.
When to use?: Always prefer relative XPath over Absolute XPath. It is the recommended method for XPath.

All Possible Ways to Write XPath in Selenium

Now let us see how you can write XPath of an element using different Attributes and functions.

We will use the below given sample login form for demonstration.

<!DOCTYPE html>
<html>
<head>
    <title>Login Page</title>
</head>
<body>
    <div class="container">
        <form id="loginForm">
            <label for="username">Username:</label>
            <input type="text" class="input-field" id="uname" name="username" placeholder="Enter username">

            <label for="password">Password:</label>
            <input type="password" id="pass" name="password" placeholder="Enter password">

            <button type="submit">Login</button>
        </form>
    </div>
</body>
</html>

1. XPath Using Different Attributes

You can locate elements using different attributes like id, name, class, and type.

Here are examples of building XPath using id, name, class, and type attributes.

Using ID attribute

If an element has an ID attribute, then you can use it to build XPath as below.

//input[@id='uname']

This XPath will locate an element with attribute id=uname.

Using Name attribute

If an element does not have an ID but a name attribute is available, then you can utilize it to generate XPath. Here is an Example:

//input[@name='username']

This XPath will locate an element with attribute name=username.

Using Class attribute

Same as ID and Name attributes, you can use the class attribute as well.

//input[@class='input-field']

This XPath will locate an element with attribute class=input-field.

Using Type attribute

You can use

//input[@type='password']

This XPath will locate an element with attribute type=password.

2. XPath Using contains() Function

You can use the contains function in XPath as below when the element has a dynamic attribute value.

//input[contains(@name, 'user')]

It will find any input field where the name contains text "user" (e.g., user123, user_login).

//button[contains(text(), 'Login')]

It will find a button that contains the text "Login" in its text.

3. XPath Using starts-with() Function

You can use the starts-with() function when an element’s attribute starts with a fixed text pattern.

//input[starts-with(@name, 'user')]

It will locate elements with name="username", name="user123", etc.

4. XPath using text() Function

You can use the text() function to find elements by their exact text value.

//button[text()='Login']

It will find a button with exact text "Login".

5. XPath Using Logical Operators (and, or)

You can use multiple conditions to narrow down your selection.

//input[@type='text' and @name='username']

It will find an <input> field that is both text-type and has the name "username".

//button[@type='submit' or text()='Login']

It will locate a button with either type="submit" or text "Login".

6. Parent-Child & Descendant XPath

Direct Child (/)

To find elements that are direct children of a parent, you can write XPath as below.

//form/input

This XPath will find input fields that are direct children of the <form>.

Any Descendant (//)

One can use given XPath to find any input field inside a <div>, even if it is deeply nested.

//form/input

7. Navigating the DOM (Parent, Sibling, Ancestors)

Moving to Parent (..)

//input[@name='password']/..

It will find the parent element of the password input field.

Finding Siblings

Next Sibling (following-sibling)

//label[@for='username']/following-sibling::input

It will locate the input field immediately after the "Username" label.

Previous Sibling (preceding-sibling)

//input[@id='pass']/preceding-sibling::label

It will locate the label before the password input field.

8. XPath Using Position (first(), last(), [n])

Locate the first element

//input[1]

It will locate the first input field on the page.

Locate the last element

//table/tbody/tr[last()]

Finds the last row in a table.

Specific Position (nth element)

//input[2]

This XPath will find the second input field from the page.

You can refer to this xpath cheat sheet which covers almost all functions, axes, predicts, expressions, and selectors.

Where to practice XPath?

You can use the Selectoshub online practice page to try all possible variations of XPath.

Using XPath Axes in Selenium WebDriver With Examples

You can use XPath Axes to navigate up, down, and sideways in the DOM. Using Axes, you can traverse the hierarchy to locate elements dynamically.

When to Use XPath Axes?

When elements do not have any unique attributes like id or name.
When you need to locate an element relative to another.
When you are dealing with complex, nested structures.

List of XPath Axes with example

child:: -> Selects Direct Children

Example: //form/child::input (It will select all input fields inside the <form>.)

parent:: -> Selects Parent of an Element

Example: //input[@id='password']/parent::form (Finds the form that contains the password field.)

descendant:: -> Selects All Nested Elements

Example: //div/descendant::input (Finds all input fields inside the <div>.)

ancestor:: -> Selects All Ancestor Elements (Upwards Traversal)

Example: //input[@id='username']/ancestor::div (Finds the div container of the username input field.)

following:: -> Selects All Elements After the Current Element.

Example: //label[@for='username']/following::input (Finds the first input field after the username label (i.e., the username input))

following-sibling:: -> Selects Next Sibling Elements

Example: //label[@for='username']/following-sibling::input (Finds the username input field, which is the next sibling of the label.)

preceding:: -> Selects All Elements Before the Current Element.

Example: //input[@id='password']/preceding::label (Finds the label for username, which comes before the password input.)

preceding-sibling:: -> Selects Previous Sibling Elements.

Example: //input[@id='password']/preceding-sibling::label (Finds the password label, which is the sibling before the password input field.)

self:: -> Selects the Current Element Itself.

Example: //input[@id='username']/self::input (Finds itself (username input field))

For best practices, you can use following-sibling:: and preceding-sibling:: to select nearby elements efficiently. Always prefer descendant:: for deep nested paths to avoid brittle XPath. Try to use ancestor:: to move up and find parent elements dynamically. following:: and preceding:: are slower, so avoid using them if not necessary.

Handling Customized Dynamic XPath In Selenium WebDriver

You need to customize XPath when the element's attributes change frequently. If an element's id, name, or class values are not static, Regular XPath expressions will not work for you. In such cases, you need to use advanced dynamic XPath.

Here are a few smart and advanced XPath examples to build and handle dynamic XPath for an Element

Using contains() for Partial Matching: //input[contains(@id, 'user_')]
Using starts-with() for Matching Beginning Text: //input[starts-with(@id, 'user_')]
Using text() for Text-Based Matching: //button[text()='Login']
Using or and and for Multiple Conditions: //input[@type='text' or @placeholder='Enter username']
Using following-sibling:: to Locate Elements Dynamically: //label[text()='Username:']/following-sibling::input
Using ancestor:: to Find Parent Elements: //input[@id='pass_987']/ancestor::form
Using last() to Get the Last Element in a List: //input[last()]

How to Use XPath in Java, Python, and C# With Selenium

For your knowledge, XPath is not dependent on any language. You can use the same XPath in all three languages.

Using XPath in Selenium With Java Example

    WebElement username = driver.findElement(By.xpath("//input[@id='username']"));
    WebElement password = driver.findElement(By.xpath("//input[@type='password']"));
    WebElement loginButton = driver.findElement(By.xpath("//button[contains(text(), 'Login')]"));

Using XPath in Selenium With Python Example

    IWebElement username = driver.FindElement(By.XPath("//input[@id='username']"));
    IWebElement password = driver.FindElement(By.XPath("//input[@type='password']"));
    IWebElement loginButton = driver.FindElement(By.XPath("//button[contains(text(), 'Login')]"));

Using XPath in Selenium With C# Example

    username = driver.find_element(By.XPATH, "//input[@id='username']")
    password = driver.find_element(By.XPATH, "//input[@type='password']")
    login_button = driver.find_element(By.XPATH, "//button[contains(text(), 'Login')]")

Best XPath extensions and Plugins For Chrome Browser

Finding XPath for each and every element is time-consuming, right? Here is a list of the top 4 free Chrome extensions for 2025 that you can use to find XPath of any web element.

Frequently Asked Selenium Interview Questions on XPath

XPath is a very important and crucial topic in an interview. Generally, interviewers are asking the following tricky questions.

1. What is XPath in Selenium, and why do we use it?

In Selenium, XPath is a way to locate an element on the page when other locators like ID, name, or find element by class name are not working. It allows you to navigate through the HTML structure and pinpoint elements precisely.

So, why use XPath?

Some elements have dynamic changing attributes. XPath works well in this scenario.
It has built-in functions and methods to search elements by text, partial text, parent-child relationships, or even positions.
It is super flexible compared to other locators.

2. What is the difference between Absolute XPath and Relative XPath?

Absolute XPath is just like giving someone turn-by-turn directions from the homepage to a specific section. It is a full path from the main HTML tag to the element. This XPath will break if anything changes in the page structure.

Example: /html/body/div[1]/table/tbody/tr[2]/td[1]

Relative XPath is more flexible as it can search from anywhere in the document instead of the root. Less chances to break when the UI updates.

Example: //table[@id='userTable']//tr[2]/td[1]

3. How do you handle dynamic elements with XPath?

Sometimes, Element's attributes like ID and name keep changing when the page reloads. In such scenarios, we can use the following smart techniques of XPath to handle them easily.

contains(): We can use contains() function when a part of attributes remain same

Example: //input[contains(@id, 'email')]

starts-with(): If the attribute's initial part remains the same, we can use the starts-with() function.

Example: //button[starts-with(@class, 'submit-btn')]

ends-with(): One can match the end part of an attribute if it remains the same.

Example: //input[ends-with(@class, 'txt')]

text(): It is useful when you are looking to locate an element based on visible text.

Example: //a[text()='Login']

last(): You can match the last matching element in a group using this function.

Example: (//input[@type='text'])[last()]

4. How do you find a parent or sibling element using XPath?

We can use XPath axes to navigate up, down, and sideways in HTML structure as follows.

To find the parent element, we can use parent::

Example: //input[@id='username']/parent::div

To find the next sibling element, we can use the following-sibling::

Example: //label[text()='Username']/following-sibling::input

To find the previous sibling element, we can use preceding-sibling::

Example: //input[@id='password']/preceding-sibling::label

These are very useful axes when a unique identifier of the element is not available. You can locate an element using the nearby element's reference.

5. What are XPath operators, and how do they help?

XPath also comes with handy operators that make searching even more powerful. Here is a list of operators with examples.

and Operator: You can use it to match both conditions.

Example of and Operator: //input[@type='text' and @name='email']

or Operator: Useful when looking to match either condition.

Example or Operator: //button[@id='submit' or @class='btn']

= Operator: Check for exact match.

Example of = Operator: //a[@href='login.html']

!= Operator: Not equal to

Example of != Operator: //input[@type!='password']

You can learn and read frequently asked Selenium Interview Questions and Answers if you are preparing for an interview.

XPath is like a Swiss Army knife for Selenium. It is so powerful, flexible and works very well when other locators struggle or fail. However, it is slower than CSS Selectors. So use it wisely. If an element has a stable ID, name, tagname or Class, go for that first. But when things get tricky, XPath is your best friend!

UI Automator Viewer : Get Android App Element's XPath, ID, Name And className

noreply@blogger.com (Unknown) — Thu, 06 Mar 2025 06:47:00 +0000

We learnt how to use UI Automator Viewer in PREVIOUS POST to locate and get properties details of android native software app's any element. Now we need to learn what are the different ways to locate elements of android software app and how to determine those locators to use them in test script. Most successful ways to locate android software app's elements are XPath, ID, Name And className so we will learn them rights now. Also we can use findElements method of webdriver to locate element of android app.We will use UI Automator Viewer to locate android app element and get it property and hierarchy detail.

PREREQUISITES : Previous 9 STEPS of appium android software test automation tutorials should be completed.

Locating Android App Element By XPath

Earlier we learnt how to locate element by XPath in selenium webdriver software testing tool in THIS POST and also given different examples to write XPath of element in different ways in THIS POST. So i am suggesting you to refer both these posts before going ahead.

We will use android calculator app to get element's XPath in different ways. Supposing I need XPath of button 5. So i can write XPath in multiple ways for it as bellow.

UI Automator Viewer screenshot for button 5 is as bellow. You can download Android Calculator App from THIS PAGE if it is not available with you.

1. XPath using class and text attribute :

In above image you can see that button 5 has text attribute with value = 5 which is unique. Class name is android.widget.Button which is same for all number buttons. So we can create XPath using text attribute value with class name as bellow.

xpath("//android.widget.Button[@text='5']")

2. XPath using class and resource-id :

Here resource-id for button 5 is com.android.calculator2:id/digit5. Trailing part (e.g digit5, digit4, digit7) of resource-id is changing for every number buttons so we can use contains function to get relative XPath of button 5 as bellow.

xpath("//android.widget.Button[contains(@resource-id,'digit5')]")

3. XPath using class, text attribute and resource-id :

We can use combination of text attribute and resource-id with class name to create unique XPath of element button 5 as bellow.

xpath("//android.widget.Button[contains(@resource-id,'digit5') and @text='5']")

4. XPath using class, text attribute and index :

We can use same approach as described in point 3 but with index number. Button 5 has index 1 but it is not unique as number buttons 0,2 and 8 has also same index with same class name. So we can include text attribute with index attribute to locate number button 5.

xpath("//android.widget.Button[@text='5' and @index='1']")

5. XPath using parent and child class hierarchy

As you can see in above image, Parent class android.widget.LinearLayout class with index = 1 has buttons 4, 5, 6 and X. So we can locate that specific row by it's class index. Child element is member of class android.widget.Button with index = 1. So we can format XPath using parent and child class hierarchy as bellow.

xpath("//android.widget.LinearLayout[@index='1']/android.widget.Button[@index='1']")

6. XPath using content-desc

Supposing element has content-desc which is unique then you can use it to create XPath. Example : DELETE button has unique content-desc = delete. So we can write XPath for delete button using it as bellow.

xpath("//android.widget.Button[@content-desc='delete']")

7. XPath using class name

Note : Using class name In By.className or By.xpath will works only if it is unique for element. If same class name is provided to multiple elements then it will not work.

If software application's element has a class name and it is unique for element then you can use class name only to create XPath. See above image. Options button has class name android.widget.ImageButton which is unique. So we can use it only to create xpath as bellow.

xpath("//android.widget.ImageButton")

Here is the latest tutorial for XPath in Selenium to locate element by attributes, Axes, operators, and dynamic XPath generation.

Locating Android App Element By ID

Earlier we learnt how to locate element by ID for web application in THIS POST. We can locate elements by ID in android app too. We can use resource-id as a id. Example is as bellow.

resource-id for button 5 is "com.android.calculator2:id/digit5" so we can locate to it by id as bellow.

id("com.android.calculator2:id/digit5")

Locating Android App Element By className
Same way, We can use class name to locate element if it is unique.

Class name for above option button is "android.widget.ImageButton". We can locate it using className as bellow.

By.className("android.widget.ImageButton")

Locating Android App element by Name
It is possible to locate element by name if element contains unique text.

If you see in above image, button Equals has text value "=". So we can locate it by name using bellow given syntax.

By.name("=")

Locating element by findElements

If you inspect all buttons of android calculator app, All the buttons has same class "android.widget.Button". If you know, findElements method is useful to get list of all the matching elements from current page as per given element locator mechanism. VIEW MORE DETAIL on findElements. So here we can collect list of all buttons using findElements and store list using java

List interface. Then we access required element using get() method of List interface.

Array list Index IDs of button elements of "android.widget.Button" class is as bellow.

List<WebElement> calcButtons = driver.findElements(By.xpath("//android.widget.Button"));

Above given syntax will store list of all buttons in list calcButtons with bellow given array list index ids. Bellow given table illustrate array index ids for different buttons of calculator application.

Button	Array index ID
DELETE	0
7	1
8	2
9	3
÷(divide)	4
4	5
5	6
6	7
×(multiply)	8
1	9
2	10
3	11
−(minus)	12
.(point)	13
0	14
=(equals)	15
+(plus)	16

So now we can access required button using it's index which is stored in list calcButtons. Means if you wants to tap on button 5 then you can use bellow given syntax.

calcButtons.get(6).click();

Here 6 is list index id of button 5 as shown in above table.

So all these are different ways to locate android software app elements. We will use all these element locator methods practically in our test scripts which I will publish in upcoming steps.

<< PREVIOUS || NEXT >>

Selenium Supported Languages: A Complete Guide

noreply@blogger.com (Unknown) — Wed, 05 Mar 2025 09:14:00 +0000

Selenium is arguably the crowned King of the automation testing tools today and one of its critical advantages is multi-language support. As an automation tester, regardless of your expertise level, it’s necessary to know what languages Selenium supports so you can select the best for your project.

In this article, we will discuss all the programming languages that are supported by Selenium, their pros and cons, and how to select the best one for your automated testing needs.

List of Selenium WebDriver Supported Programming Languages

Now, let's explore the languages supported by Selenium WebDriver:

1. Java

Popular language: It is one of the most widely used languages in Selenium automation testing.
Good Community Support: It has a good developer and tester community support and has an extensive library.
Easy to Integrate: You can integrate it easily with TestNG, JUnit, and Maven.
Fast test execution: Test scripts are executed faster in Java.

Example:

    WebDriver driver = new ChromeDriver();
    driver.get("https://www.google.com");
    System.out.println("Title: " + driver.getTitle());
    driver.quit();

2. Python

Simple syntax, easy to learn: It has simpler syntax compared to other languages. Also, it is easy to learn for beginners.
Works well with PyTest and Behave for BDD: It is easy to integrate with powerful testing framework PyTest and Behave to execute parameterized tests and parallel execution.

Example:

from selenium import webdriver

driver = webdriver.Chrome()
driver.get("https://www.google.com")
print("Title:", driver.title)
driver.quit

3. C#

Popular among .NET developers: It is one of the most popular language among .NET developers who are working in Selenium automation testing.
Easy to Integrate: You can integrate it easily with the NUnit and MSTest frameworks.
You can use it for enterprise-level applications.

Example:

using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;

class Program {
    static void Main() {
        IWebDriver driver = new ChromeDriver();
        driver.Navigate().GoToUrl("https://www.google.com");
        Console.WriteLine("Title: " + driver.Title);
        driver.Quit();
    }
}

4. JavaScript (Node.js with WebDriverIO)

It is an Ideal language for full-stack developers who are using JavaScript.
It works well with different frameworks like Mocha, Jasmine, and Protractor.

Example:

const { Builder } = require('selenium-webdriver');

(async function example() {
    let driver = await new Builder().forBrowser('chrome').build();
    await driver.get('https://www.google.com');
    let title = await driver.getTitle();
    console.log("Title:", title);
    await driver.quit();
})();

5. Ruby

It is popular among testers who are looking to perform behavior-driven testing with Cucumber.
It has very simple and elegant syntax.

Example:

require 'selenium-webdriver'

driver = Selenium::WebDriver.for :chrome
driver.navigate.to "https://www.google.com"
puts "Title: #{driver.title}"
driver.quit

6. PHP

PHP is less famous with Selenium, but it is still supported if you love to code in PHP.
It is suitable for web-based test automation in PHP projects.

Example:

<?php
require 'vendor/autoload.php';
use Facebook\WebDriver\Chrome\ChromeDriver;
use Facebook\WebDriver\WebDriverBy;

$driver = ChromeDriver::start();
$driver->get("https://www.google.com");
echo "Title: " . $driver->getTitle();
$driver->quit();

7. Perl

It is also less commonly used language. But selenium supports it so it is necessary to mention it.
Best for testers and developers who are familiar with Perl scripting.

Example:

use Selenium::Remote::Driver;

my $driver = Selenium::Remote::Driver->new(browser_name => 'chrome');
$driver->get('https://www.google.com');
print "Title: " . $driver->get_title() . "\n";
$driver->quit();

How to Choose the Right Language for Selenium?

If you are confused in language selection for the selenium project, you need to consider many different factors. Choosing the right language for Selenium is just like selecting the best tool for the job. You need something comfortable to you, fulfill your need, and easy to use, right? Here is a step-by-step guide on how to choose the right language.

First of all, let's see quickly which language is best for you.

Go with Java if you want scalability and performance.
Choose Python if you want simplicity and quick test automation.
Pick C# if you're working in a Microsoft environment.
Use JavaScript if your app is web-based and built in JavaScript.

Now let's see a detailed description on how to select the best language for Selenium.

1. What’s Your Comfort Zone?

First thing first. Which language is comfortable for you? If you are already comfortable with Java, C#, or Python, you can start with it. Learning a new language for Selenium is not necessary unless there’s a strong reason to switch.

2. The Most Popular Choices

As we earlier discussed, Selenium supports multiple languages. But here is a list of languages that are used most with selenium in 2025.

Java:

Pros: It is the most widely used language with Selenium. You will find tons of resources, great community support, and highly scalable.
Cons: It is a little bit verbose. It is cumbersome to write and maintain tests in Java.

Python:

Pros: It is very simple, easy to write, and great to write quick automation scripts.
Cons: However, it sometimes lags behind Java in feature updates.

Pros: If you are working with Microsoft technologies, C# is a great pick.
Cons: Smooth integration with Visual Studio, but not as commonly used as Java.

JavaScript (Node.js):

Pros: Ideal for web-based projects. If your app is built in JavaScript, this might be the best choice.
Cons: Async programming can be tricky for beginners.

3. What Else Are You Using?

Think about the bigger picture. What other tools or frameworks are you going to use with Selenium like TestNG, JUnit, PyTest, or Mocha? Some languages work better with certain testing frameworks like JUnit, and TestNG works better with Java. If you already use such tools, then it is best to select the language based on them.

4. Community & Support Matter!

If you select an odd language, you will get stuck when a problem arises as no one will be there to help you. Java and Python have massive Selenium communities, meaning more tutorials, documentation, and Stack Overflow answers when things go sideways.

5. Speed & Performance

If you’re running large, complex test suites, you can choose Java because it is usually the fastest in execution.
If you need something lightweight and easy to maintain, Python is a great pick.
If your app is built in JavaScript, JS (Node.js) will be a seamless and best fit for you.

6. What’s Your Long-Term Plan?

If you are a freelancer or looking for a job in automation, then Java and Python are the best languages for Selenium because both of them are dominating the job market. But if you are already working with some company and they are working with another language, then you can go with it.

At the end of the day, the best language is the one that helps you get the job done without unnecessary headaches. So, what’s your pick? Let me know in the comments!

Selenium Interview Questions and Answers

noreply@blogger.com (Unknown) — Wed, 05 Mar 2025 04:55:00 +0000

Are you preparing for an interview for a Selenium automation testing Job in 2025? Whether you're just a beginner in Selenium or have 3 Years, 5 years, or 10 years of experience in automation testing, being well-prepared before an interview can make all the difference. Selenium is universally used and one of the most popular automation testing tools, and companies are always looking for skilled testers and developers who have a strong understanding of it.

To help you prepare, I have compiled a set of commonly asked Selenium interview questions and answers based on actual Selenium automation problems and industry best practices. I have automated several projects and have assisted teams in resolving real-world problems with Selenium automation. These are real answers drawn from real experience because I know what works and what does not in real life.

No matter what level of knowledge a person has, these questions seem to encapsulate everything from basic core understanding to advanced level framework building tasks done by a test automation engineer. Whether you are looking for a QA engineer position, test automation developer, or an SDET, this information will definitely help you in your next interview.

Basic Selenium Interview Questions

1. What is Selenium?

Selenium is a free automation testing tool that was initially developed by Jason Huggins. It is used to test web applications on different browsers and platforms. It is not only a browser automation tool, but you can automate your web-based repetitive tasks as well using Selenium.

You can use it to automate testing across several programming languages to develop test scripts. It also supports cross-browser and cross-platform testing using Selenium Grid. You can run Selenium tests on different browsers like Chrome, Firefox, Edge, Opera, and Safari to check browser compatibility. Also, you can run test scripts on different OS easily like Windows, Linux, and mac OS.

Unlike other automation tools, it interacts with browsers natively just like a real user. So it is easy to find UI level bugs as well.

2. What are the different components of Selenium?

Selenium consists of four main components:

Selenium IDE – Shinya Kasatani developed it in 2006. Selenium IDE is an easy-to-use, open source browser extension that is used to record and play back test scripts.
Selenium WebDriver – Selenium WebDriver is a very popular and powerful tool for programmatically automating browser interactions.
Selenium Grid – Used for parallel execution of tests across multiple machines and browsers.
Selenium RC (Deprecated) – The old version of Selenium WebDriver.

3. How does Selenium WebDriver work?

Selenium WebDriver interacts with the browser using a browser-specific driver, i.e. ChromeDriver for Chrome, geckodriver for Firefox, etc. Selenium 3 was using JSON Wire Protocol to communicate with browsers. However, the newer version, Selenium 4, primarily uses the W3C WebDriver protocol to send commands and automate actions like clicking, typing, and navigating web pages.

4. What are the advantages of using Selenium for automation testing?

Here are the main advantages that you can explain to the interviewer.

Cost Effective: It is open-source and free, which is the main advantage.
Multi Language Support: No language specific dependency. It supports multiple programming languages.
Platform Independent: No browser specific dependency. It supports multiple browsers.
Saves Time: Selenium Grid allows for parallel test execution, which can save you significant time.
Flexible & Easy Integration: Works with various testing frameworks (TestNG, JUnit, NUnit, Jenkins CI/CD, etc.)
Active Community Support: Wide community support. Easy to find solutions online.
Automate Tests as a Real User Do: It interacts with browsers directly. Same as a real user does.
Create Framework As per Your Convenience: You can create different frameworks like data-driven, keyword-driven, Hybrid, etc, easily, as per your requirement.

5. What are the limitations of Selenium?

Main limitations are

Cannot automate desktop applications.
Limited support to test mobile apps (needs Appium for that)
No built-in reporting feature.
Cannot handle captchas and OTPs directly
It is challenging to handle pop-ups and dynamic web elements in Selenium.

6. What programming languages does Selenium support?

Selenium supports Java, Python, C#, Ruby, and JavaScript.

7. What types of applications can Selenium automate?

It can automate web applications only. You can test mobile apps with the help of Appium. You need third-party tools to automate desktop applications.

8. How do you set up Selenium WebDriver in a project?

Download and install Java or Python.

Install Eclipse or PyCharm IDE as per the programming language you are working on.

Install Selenium WebDriver using Maven (Java) or pip (Python).

Download the required browser driver (e.g., ChromeDriver for Chrome).

Write and execute your test script.

9. What are the different locators in Selenium?

Selenium provides 8 locators to find web elements:

ID – driver.findElement(By.id("username"))
Name – driver.findElement(By.name("email"))
Class Name – driver.findElement(By.className("login-btn"))
Tag Name – driver.findElement(By.tagName("input"))
Link Text – driver.findElement(By.linkText("Click Here"))
Partial Link Text – driver.findElement(By.partialLinkText("Click"))
CSS Selector – driver.findElement(By.cssSelector("#login"))
XPath – driver.findElement(By.xpath("//input[@id='password']"))

10. What is the difference between findElement() and findElements()?

findElement() method will return a single Web Element (throws an error if element not found)

Example: WebElement element = driver.findElement(By.id("login")); // Returns a single element.

findElements() method is used to get a list of Web Elements (returns an empty list if element not found).

Example: List<WebElement> elements = driver.findElements(By.tagName("a")); // Returns a list of links

11. What is the difference between driver.get() and driver.navigate().to()?

driver.get("URL"): You can use it to load a new webpage and wait until it’s fully loaded.

Example: driver.get("https://example.com");

driver.navigate().to("URL") – It is similar to the get() method, but provides additional navigation features like back, forward, and refresh.

Example: driver.navigate().to("https://example.com");

12. How do you handle browser navigation in Selenium?

We can use the navigate() method for browser navigations.

Examples:

To go back to the previous page, we can use driver.navigate().back();

We can use driver.navigate().forward(); to go forward.

This syntax is used to refresh the page: driver.navigate().refresh();

13. How do you handle different types of waits in Selenium?

We mainly use 3 types of waits in Selenium tests as below.

1. Implicit Wait

Implicit wait is used to wait for elements globally.

Example of Implicit Wait: Given syntax will wait for 10 seconds while page is loading.

driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);

2. Explicit Wait

Explicit wait is used to wait for specific conditions.

Example of Explicit Wait: Given syntax will wait for 10 seconds for the element with the 'login' id to be visible.

WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));

wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("login")));

3. Fluent Wait

Similar to Explicit Wait but with polling intervals.

14. What is the difference between implicit wait and explicit wait?

The main differences between implicit and explicit wait are given below.

Implicit Wait

Applies to: All elements globally.

Usage: driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);

Checks conditions?: No

Explicit wait

Applies to: Specific elements

Usage: WebDriverWait wait = new WebDriverWait(driver, 10);

Checks conditions?: Yes (e.g., element visibility, clickable, etc.)

15. What is a Fluent Wait in Selenium?

A Fluent Wait in Selenium is a type of dynamic wait that allows you to specify

The maximum amount of time to wait for a condition,
The polling frequency.
Ignoring specific exceptions while waiting.

Example:

Wait<WebDriver> wait = new FluentWait<>(driver)
    .withTimeout(Duration.ofSeconds(10))
    .pollingEvery(Duration.ofSeconds(1))
    .ignoring(NoSuchElementException.class);

16. How do you handle pop-ups and alerts in Selenium?

We can handle pop-ups and alerts using the Alert interface. We can use the accept() method to accept or click on the OK button, the dismiss() method to dismiss/cancel the alert. Also, it is possible to type text in the text field of alert using sendKeys() method.

Here is an example.

    Alert alert = driver.switchTo().alert();
    alert.accept(); // Click OK  
    alert.dismiss(); // Click Cancel  
    alert.sendKeys("Hello"); // Send text

17. How do you work with multiple browser windows in Selenium?

We can use the getWindowHandles() method to switch between windows.

Example:

    String mainWindow = driver.getWindowHandle();
        for (String window : driver.getWindowHandles()) {
        driver.switchTo().window(window);
    }

18. What is the difference between switchTo().window() and switchTo().frame()?

Difference between switchTo().window() and switchTo().frame() is as below.

switchTo().window("windowID"): It is used to switch between browser tabs/windows.
switchTo().frame("frameID"): It is used to switch to an iframe on the page.

19. How do you handle dropdowns in Selenium?

We can use the Select class to handle alerts in Selenium. Here is an example on how to select dropdown options using visible text, value, and index.

    Select dropdown = new Select(driver.findElement(By.id("dropdown")));
    dropdown.selectByVisibleText("Option 1");
    dropdown.selectByValue("option1");
    dropdown.selectByIndex(0);

20. How do you select a value from a dropdown using Selenium?

There are three ways to select a value from a dropdown.

selectByVisibleText("Option")
selectByValue("option1")
selectByIndex(0)

Example:

Select dropdown = new Select(driver.findElement(By.id("dropdown")));
dropdown.selectByVisibleText("Java");

Selenium WebDriver Questions

21 What is WebDriver in Selenium?

Selenium WebDriver is a browser automation framework. Simply, it automates the browsers. It is open-source so you can use it for free. It allows you to interact with web applications just like a real user. It acts as a mediator to send commands to web browsers and execute actions like clicking buttons, typing text in a textbox, navigating between pages, and many more actions.

Here are key features of WebDriver:

It can directly communicate with the browser.
It supports multiple browsers like Chrome, Firefox, Edge, Safari, etc.
Works with multiple programming languages like Java, Python, C#, JavaScript, etc.
You can easily use it on different OS like Windows, Linux, and Mac.

WebDriver is one of the most commonly used components of Selenium framework. You can use it to perform UI testing, regression testing, functional testing, cross-browser testing, database testing, and parallel testing.

You can read this article to read more about WebDriver in Selenium.

22. How do you launch different browsers in Selenium WebDriver?

I am using the browser-specific driver executable to launch the browser in Selenium test. I am using Chromedriver to run tests in Google Chrome browser, GeckoDriver for Mozilla Firefox browser, and EdgeDriver to launch tests in Edge browser. Here is a detailed guide on how to download and configure Chromedriver, GeckoDriver, and EdgeDriver to use them in Selenium WebDriver.

Here are the examples to launch different browsers in Selenium WebDriver test.

Example to launch Chrome browser in Selenium

        WebDriver driver = new ChromeDriver();
        driver.get("https://example.com");

Example to launch Firefox browser in Selenium

        WebDriver driver = new FirefoxDriver();
        driver.get("https://example.com");

Example to launch Edge browser in Selenium

        WebDriver driver = new EdgeDriver();
        driver.get("https://example.com");

Example to launch Safari browser in Selenium

        WebDriver driver = new SafariDriver();
        driver.get("https://example.com");

23. What is the difference between WebDriver and RemoteWebDriver?

WebDriver is an interface in Selenium that allows communication directly with browsers. You can use browser-specific drivers like ChromeDriver, GeckoDriver, or EdgeDriver, to execute commands on browsers in the local system.

On the other hand, RemoteWebDriver is a class that enables running Selenium tests on a remote machine. It communicates with the remote browser using the W3C WebDriver Protocol (previously JSON Wire Protocol in older Selenium versions). Generally, we use RemoteWebDriver to perform distributed testing, Selenium Grid, and cloud-based automation on platforms like BrowserStack and Sauce Labs.

Key Differences:

Execution Location:

WebDriver executes Selenium tests on the local machine.
RemoteWebDriver runs tests remotely on another machine or cloud service.

Communication Protocol:

WebDriver directly interacts with the browser drivers.
RemoteWebDriver executes Selenium commands using the W3C WebDriver Protocol over HTTP.

Use Case:

WebDriver is best for local automation on a single browser instance.
You can use RemoteWebDriver to perform parallel execution across multiple machines in Selenium Grid or cloud testing services.

Example of WebDriver (Local Execution)

        WebDriver driver = new ChromeDriver();
        driver.get("https://example.com");

Example of RemoteWebDriver (Remote Execution)

        URL remoteUrl = new URL("http://192.168.1.100:4444"); // Selenium Grid URL
        ChromeOptions options = new ChromeOptions(); // Use browser options instead of DesiredCapabilities

        WebDriver driver = new RemoteWebDriver(remoteUrl, options);
        driver.get("https://example.com");

24. How do you maximize a browser window in Selenium?

In Selenium WebDriver, there are two ways to maximize window size. 1) You can use the maximize_window() method, and 2) You can use the setSize() method to manually set the maximized size as per your screen size. If you are using Headless Browsers, you can use addArguments("--start-maximized") to maximize window size.

Let's see examples

Example of Maximizing window using maximize_window() method

    // Set up the WebDriver (Make sure ChromeDriver path is set in system properties)
    WebDriver driver = new ChromeDriver();

    // Open a website
    driver.get("https://www.example.com");

    // Maximize the browser window
    driver.manage().window().maximize();

    // Perform any test actions...

    // Close the browser
    driver.quit();

Here, driver.manage().window().maximize(); syntax will maximize the window.

Example of Maximizing window using setSize() method

       WebDriver driver = new ChromeDriver();        
       driver.manage().window().setSize(new Dimension(1200, 800));

If your screen size is 1200 x 800, then you can use the .setSize() method to maximize the window.

Example of Maximizing window in Headless Browsers using addArguments("--start-maximized")

        WebDriver driver;
	FirefoxOptions options=new FirefoxOptions();
	//To open  browser in Headeless mode.
	options.addArguments("--headless");	
	//To open headless browser maximized.
	options.addArguments("--start-maximized");
	driver = new FirefoxDriver(options);

The above example explains how to start a headless browser maximized.

Tips: You should run Selenium tests in a full-screen environment to prevent UI interaction issues.

25. How do you take a screenshot in Selenium WebDriver?

We can use the TakesScreenshot interface to capture a screenshot while running the Selenium test.

Example to take a Screenshot and Save as a File in Selenium

package com.secondpr;
import org.openqa.selenium.*;
import org.openqa.selenium.chrome.ChromeDriver;
import java.io.File;
import java.io.IOException;
import org.apache.commons.io.FileUtils;

public class takeScreenShot {

	public static void main(String[] args) {
	// Set up WebDriver
        WebDriver driver = new ChromeDriver();

        try {
            // Open a website
            driver.get("https://www.example.com");

            // Take a screenshot
            TakesScreenshot ts = (TakesScreenshot) driver;
            File source = ts.getScreenshotAs(OutputType.FILE);

            // Define destination path
            File destination = new File("D:\\homePageScreenshot.png");

            // Copy file to the destination
            FileUtils.copyFile(source, destination);

            System.out.println("Screenshot saved successfully!");
        } catch (IOException e) {
            System.out.println("Error while saving screenshot: " + e.getMessage());
        } finally {
            // Close the browser
            driver.quit();
        }
	}
}

Note: You need to add external binary jars of commons-io. You can download the latest jars from the Apache Commons IO Download page.

26. How do you get the title of a webpage in Selenium?

In Selenium WebDriver, you can get the title of a webpage using the getTitle() method.

Example to get webpage title:

        // Get and print the title of the webpage
        String pageTitle = driver.getTitle();
        System.out.println("Page Title: " + pageTitle);

Here, driver.getTitle(); retrieves the title of the current webpage. It is useful to validate if the correct page is loaded during automation testing. Generally, this method is used to assert the expected title in test cases.

27. How do you get the current URL of a webpage?

In Selenium WebDriver, you can use the getCurrentUrl() method to get the current URL of a webpage.

Example to get current URL of WebPage:

        // Get and print the current URL
        String currentURL = driver.getCurrentUrl();
        System.out.println("Current URL: " + currentURL);

In the above example, driver.getCurrentUrl() method will return the current URL of the webpage. You can use it to validate or assert that the correct page is loaded.

28. How do you handle cookies in Selenium WebDriver?

In Selenium WebDriver, you can use getCookies(), addCookie(), getCookieNamed(), deleteCookieNamed(), and deleteAllCookies() methods to add, retrieve, delete, and clear cookies.

An example to manage cookies

package com.secondpr;

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.Cookie;
import java.util.Set;

public class manageCookies {

	public static void main(String[] args) {
		
		WebDriver driver = new ChromeDriver();

        // Open a website
        driver.get("https://only-testing-blog.blogspot.com/");

        // 1. Get all cookies
        Set<Cookie> allCookies = driver.manage().getCookies();
        System.out.println("All Cookies: " + allCookies);

        // 2. Get a specific cookie by name
        Cookie specificCookie = driver.manage().getCookieNamed("session_id");
        System.out.println("Session Cookie: " + specificCookie);

        // 3. Add a new cookie
        Cookie newCookie = new Cookie("test_cookie", "123456");
        driver.manage().addCookie(newCookie);
        System.out.println("Added new cookie: " + newCookie);
        
        // 4. Delete a specific cookie
        driver.manage().deleteCookieNamed("test_cookie");
        System.out.println("Deleted 'test_cookie'");

        // 5. Delete all cookies
        driver.manage().deleteAllCookies();
        System.out.println("All cookies deleted");

        // Close the browser
        driver.quit();	}

}

Explanation of Cookie Handling Methods

driver.manage().getCookies(); → Fetches all cookies.
driver.manage().getCookieNamed("cookie_name"); → Retrieves a specific cookie by name.
driver.manage().addCookie(new Cookie("name", "value")); → Adds a new cookie.
driver.manage().deleteCookieNamed("cookie_name"); → Deletes a specific cookie.
driver.manage().deleteAllCookies(); → Clears all cookies.

Why Handle Cookies in Selenium?

To maintain user sessions without logging in repeatedly.
Test authentication by manually adding session cookies.

29. How do you delete all cookies using Selenium?

You can use the deleteAllCookies() method for it as described in the example of the previous question's answer.

30. What is the difference between close() and quit()?

Here are the Main differences between close() and quit() methods.

Functionality:

close(): Closes the current browser window.
quit(): Closes all browser windows opened by Selenium.

Scope:

close(): Only the active browser window is closed.
quit(): All browser sessions initiated by WebDriver are closed.

WebDriver Instance:

close(): WebDriver session remains active if multiple windows exist.
quit(): WebDriver session is terminated completely.

Usage:

close(): Used when handling multiple windows/tabs and only one needs to be closed.
quit(): Used when the entire test execution is complete and no further actions are needed.

Tips: You can use close() when you want to close only the current window but keep WebDriver running. But you can use the quit() method to close all browser windows and end the WebDriver session.

Best Practice: Always use quit() at the end of the test execution to avoid memory leaks!

31. How do you handle JavaScript alerts in Selenium?

There are three types of JavaScript alerts:

Simple Alert → Only has an "OK" button.
Confirmation Alert → Has "OK" and "Cancel" buttons.
Prompt Alert → Has a text box, along with "OK" and "Cancel" buttons.

Here is an explanation on how to manage alerts in Selenium.

Switch to alert:

You can use the given syntax to switch Selenium test execution on alert.

Alert alert = driver.switchTo().alert();

Accepting an Alert (OK Button)

alert.accept(); // Clicks "OK" button.

Dismissing an Alert (Cancel Button)

alert.dismiss(); // Clicks "Cancel" button.

Getting the Alert Message

String alertText = alert.getText();

System.out.println("Alert Message: " + alertText);

Handling Prompt Alert (Entering Text)

alert.sendKeys("Test Input"); // Enter text in the alert box

alert.accept(); // Clicks "OK" button.

Handling alerts is important for pop-ups, form validations, and confirmations in test automation.

32. How do you perform drag and drop in Selenium?

In Selenium, you can use the Actions class to perform drag and drop actions.

Here is an example of drag and drop

package com.secondpr;

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.interactions.Actions;

public class dragDrop {

	public static void main(String[] args) {
	// Set up WebDriver
        WebDriver driver = new ChromeDriver();

        // Open a website with drag-and-drop functionality
        driver.get("https://jqueryui.com/droppable/");

        // Switch to iframe if the elements are inside one
        driver.switchTo().frame(0);

        // Locate source (element to be dragged) and target (element where to drop)
        WebElement source = driver.findElement(By.id("draggable"));
        WebElement target = driver.findElement(By.id("droppable"));

        try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
        // Perform drag and drop
        Actions actions = new Actions(driver);
        actions.dragAndDrop(source, target).perform();
        
        try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

        System.out.println("Drag and drop successful!");

        // Close browser
        driver.quit();
	}
}

The above example will drag an element from the source and drop it on the destination. Try it.

Other Ways to Perform Drag and Drop

Using clickAndHold(), moveToElement(), and release(). You can use this method when dragAndDrop() doesn’t work due to JavaScript interference.

Example:

actions.clickAndHold(source)

.moveToElement(target)

.release()

.build()

.perform();

Using moveByOffset() (Dragging to Specific Coordinates). You can use it when drop location is dynamic or doesn’t have a unique identifier.

Example:

actions.clickAndHold(source)

.moveByOffset(100, 50) // Move by X and Y offset

.release()

.perform();

Tips:

Use dragAndDrop(source, target).perform(); for standard cases.
Use clickAndHold(), moveToElement(), and release() if dragAndDrop() doesn’t work.
Use moveByOffset(x, y) for pixel-based movement.
Always switch to the iframe first if elements are inside it.

You can use drag and drop for file uploads, game testing, and UI interactions.

33. How do you simulate keyboard and mouse actions in Selenium?

You can use Actions and Robot classes to simulate keyboard and mouse actions.

Using Actions Class (Recommended)

Mouse Actions Example

    Actions actions = new Actions(driver);
    actions.moveToElement(element).perform();  // Hover  
    actions.contextClick(element).perform();   // Right-click  
    actions.doubleClick(element).perform();    // Double-click

Keyboard Actions

    actions.sendKeys(Keys.ENTER).perform();  // Press Enter  
    actions.keyDown(Keys.SHIFT).sendKeys("text").keyUp(Keys.SHIFT).perform();  // Type in uppercase

Using Robot Class (For Advanced Interactions)

Keyboard Input

    Robot robot = new Robot();
    robot.keyPress(KeyEvent.VK_ENTER);
    robot.keyRelease(KeyEvent.VK_ENTER);

Mouse Actions

    robot.mouseMove(500, 300);  // Move mouse  
    robot.mousePress(InputEvent.BUTTON1_DOWN_MASK);  // Left-click  
    robot.mouseRelease(InputEvent.BUTTON1_DOWN_MASK);

Tips:

You can use the Actions class for web-based interactions, i.e. hover, right-click, drag & drop, keyboard inputs, and the Robot class for system-level interactions, i.e.. file uploads, screenshots, handling OS pop-ups. Actions class is preferred for browser-based automation, while Robot is used when Actions doesn't work.

34. What is the Actions class in Selenium?

The Actions class in Selenium performs advanced user interactions, such as mouse hover, right-click, double-click, drag-and-drop, and keyboard actions. It helps automate complex gestures that require a combination of keyboard and mouse events.

Its key features include mouse actions, keyboard inputs, and composite gestures for seamless automation.

35. What is the difference between Action and Actions class?

Main differences between Action and Actions class are:

Type:

Action class: It is an Interface.
Actions class: It is a Class.

Purpose:

Action class: It represents a single action.
Actions class: It is used to build and perform a series of actions.

Usage:

Action class: It stores one action at a time.
Actions class: It has a chain of multiple actions together.

Here is an example of the Action interface and the Actions class

// Using Actions class to build and perform actions
Actions actions = new Actions(driver);
actions.moveToElement(element).click().perform(); // Hover and click

// Using Action interface to store an action
Action action = actions.moveToElement(element).click().build();
action.perform(); // Perform stored action

36. How do you simulate right-click in Selenium?

We can simulate a right-click in Selenium using the contextClick() method from the Actions class.

Example:

        WebElement element = driver.findElement(By.id("rightClickElement"));
        Actions actions = new Actions(driver);
        actions.contextClick(element).perform();  // Right-click action

37. How do you simulate double-click in Selenium?

You can perform a double-click in Selenium using the doubleClick() method from the Actions class.

Here is an example:

        WebElement element = driver.findElement(By.id("doubleClickElement"));

        Actions actions = new Actions(driver);
        actions.doubleClick(element).perform();  // Double-click action

38. How do you handle frames and iframes in Selenium?

In Selenium, you can switch to a frame or iframe using the switchTo().frame() method. You can switch to frame using Index, name, or ID, or a WebElement.

Here are examples using different methods:

Example of switch to frame by Index:

    driver.switchTo().frame(0);  // Switch to the first frame

Example of switch to frame by Name or ID:

    driver.switchTo().frame("frameName");  // Switch using frame name or ID

Example of switch to frame by WebElement:

    WebElement frameElement = driver.findElement(By.tagName("iframe"));
    driver.switchTo().frame(frameElement);  // Switch using WebElement

Example of Switch Back to Main Page:

driver.switchTo().defaultContent();  // Exit from frame to main content

39. How do you work with checkboxes and radio buttons in Selenium?

In Selenium, you can interact with checkboxes and radio buttons using the click(), isSelected(), and getAttribute() methods.

Here is an example of Selecting a Checkbox and Radio Button.

WebElement checkbox = driver.findElement(By.id("subscribe"));
checkbox.click();  // Click to select

// Verify if checkbox is selected
if (checkbox.isSelected()) {
    System.out.println("Checkbox is selected.");
}

WebElement radioButton = driver.findElement(By.id("genderMale"));
radioButton.click();  // Select radio button

40. How do you handle hidden elements in Selenium?

You can not interact with hidden elements directly in Selenium. But, you can use the following methods to interact with them.

JavaScript Executor (Force Click)

JavascriptExecutor js = (JavascriptExecutor) driver;
WebElement hiddenElement = driver.findElement(By.id("hiddenButton"));
js.executeScript("arguments[0].click();", hiddenElement);

Checking Visibility Before Action

WebElement element = driver.findElement(By.id("hiddenElement")); if (element.isDisplayed()) { element.click(); } else { System.out.println("Element is hidden"); }

Using Actions Class (For Hover to Reveal Elements)

Actions actions = new Actions(driver);
WebElement menu = driver.findElement(By.id("menu"));
actions.moveToElement(menu).perform();  // Hover to make hidden element visible

Selenium Automation Framework Questions

41. What is a Selenium Framework?

Types of Selenium Frameworks:

Data-Driven Framework → Uses external data sources (Excel, CSV). You can use it to test multiple inputs without modifying scripts.

String data = excelSheet.getCellData("TestData.xlsx", "Sheet1", 1, 1);

Keyword-Driven Framework → Uses predefined keywords for test execution. It helps you to separate test logic from the script.

executeAction("Click", "loginButton");

Hybrid Framework → Combines Data-Driven + Keyword-Driven approaches. It works well for large-scale automation projects.

Page Object Model (POM) → Organizes elements and actions into separate classes. It helps to improve code reusability & readability.

LoginPage login = new LoginPage(driver);
login.enterUsername("user");
login.clickLogin();

42. What are the different types of Selenium frameworks?

Frameworks are already mentioned in the previous answer.

43. What is the Page Object Model (POM) in Selenium?

The Page Object Model (POM) is a design pattern that helps organize Selenium test scripts by separating UI elements and test logic into different classes. It enhances the usability, maintenance, and readability of test scripts.

Key Advantages of POM:

Helps to reduce duplicate code.
Enhances test script readability.
Easy to maintain test scripts when UI changes.

Example of POM:

Create a Page Class (LoginPage.java)

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.By;

public class LoginPage {
    WebDriver driver;

    // Locators
    By username = By.id("user");
    By password = By.id("pass");
    By loginButton = By.id("login");

    // Constructor
    public LoginPage(WebDriver driver) {
        this.driver = driver;
    }

    // Methods to interact with elements
    public void enterUsername(String user) {
        driver.findElement(username).sendKeys(user);
    }

    public void enterPassword(String pass) {
        driver.findElement(password).sendKeys(pass);
    }

    public void clickLogin() {
        driver.findElement(loginButton).click();
    }
}

Use the Page Class in a Test (LoginTest.java)

WebDriver driver = new ChromeDriver();
driver.get("https://example.com");

LoginPage login = new LoginPage(driver);
login.enterUsername("testUser");
login.enterPassword("testPass");
login.clickLogin();

44. What are the advantages of using POM?

Main advantages of POM are as below.

Better Code Maintainability – You need to update only the page classes, If there is any change in the UI. Do not need to update all test cases.
Increased Reusability – You can reuse common UI actions like login, search across multiple tests.
Improved Readability – Test scripts are cleaner and easier to understand.
Separation of Concerns – Keeps test logic separate from UI element locators.
Reduces Code Duplication – No need to define locators in multiple places.

45. What is Page Factory in Selenium?

Page Factory is an optimized way to implement the Page Object Model (POM) in Selenium. It simplifies element initialization using the @FindBy annotation and PageFactory.initElements(), which makes test scripts cleaner and more efficient.

Key Benefits of Page Factory

Automatic element initialization using @FindBy.
Improves readability & maintainability of test scripts.
Faster execution due to lazy loading of elements.

Example of Page Factory Implementation

Define Page Class (LoginPage.java)

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.FindBy;
import org.openqa.selenium.support.PageFactory;

public class LoginPage {
    WebDriver driver;

    // Locate elements using @FindBy annotation
    @FindBy(id = "user") 
    WebElement username;

    @FindBy(id = "pass") 
    WebElement password;

    @FindBy(id = "login") 
    WebElement loginButton;

    // Constructor to initialize Page Factory
    public LoginPage(WebDriver driver) {
        this.driver = driver;
        PageFactory.initElements(driver, this);
    }

    // Methods to interact with elements
    public void enterUsername(String user) {
        username.sendKeys(user);
    }

    public void enterPassword(String pass) {
        password.sendKeys(pass);
    }

    public void clickLogin() {
        loginButton.click();
    }
}

Use Page Factory in Test (LoginTest.java)

WebDriver driver = new ChromeDriver();
driver.get("https://example.com");

LoginPage login = new LoginPage(driver);
login.enterUsername("testUser");
login.enterPassword("testPass");
login.clickLogin();

46. How is Page Factory different from POM?

Key differences between page object model and page factory are as below.

Element Initialization:

POM: Uses driver.findElement() manually.
Page Factory: Uses @FindBy annotation with PageFactory.initElements()

Code Readability:

POM: Requires more lines of code.
Page Factory: Cleaner and more concise

Performance:

POM: Loads elements immediately.
Page Factory: Uses lazy initialization, loading elements only when needed.

Maintainability:

POM: Requires explicit element declaration.
Page Factory: Automatically initializes elements, making maintenance easier.

47. How do you handle dynamic elements in Selenium?

Dynamic elements have changing attributes (like IDs or XPaths) on every page load. You can handle them using:

Using Dynamic XPath

Identify elements with partial attributes or text.

WebElement element = driver.findElement(By.xpath("//*[contains(@id, 'dynamicPart')]"));

Using CSS Selectors with Wildcards

Target elements with starts-with (^), ends-with ($), or contains (*) attributes.

WebElement element = driver.findElement(By.cssSelector("[id^='start']"));

Using Explicit Wait

Wait until the element is visible or clickable.

WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement element = wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("dynamicElement")));

Using JavaScript Executor (If Element is Not Detected)

Fetch the element using JavaScript.

JavascriptExecutor js = (JavascriptExecutor) driver;
WebElement element = (WebElement) js.executeScript("return document.querySelector('[id^=\"dynamic\"]');");

48. What is TestNG?

Full form of TestNG is Test Next Generation. It is a powerful testing framework in Java. It is designed to simplify test execution and reporting. It is widely used in Selenium automation for managing test cases efficiently.

Key Features of TestNG:

Annotations: We can use annotations like @Test, @BeforeMethod, @AfterMethod for structured testing.
Parallel Test Execution: Allows to run multiple tests simultaneously.
Assertions: Has great assertions for result validation.
Report Generation: Can generate detailed test results.

49. What are the advantages of using TestNG?

Here are the advantages of using TestNG in Selenium.

Annotations for Better Test Structure → Uses @Test, @BeforeMethod, @AfterMethod for organized test execution.

Parallel Test Execution → Runs multiple tests at the same time, reducing execution time.

Built-in Reporting → Generates detailed HTML test reports automatically.

Data-Driven Testing with @DataProvider → Enables testing with multiple data sets.

Flexible Test Execution with XML → Run specific tests by modifying the testng.xml file.

Example:

@DataProvider(name = "loginData")
public Object[][] getData() { return new Object[][] { {"user1", "pass1"}, {"user2", "pass2"} }; }

50. What is the difference between JUnit and TestNG?

Here are the differences of JUnit and TestNG features.

JUnit

Annotations: You can use @Test, @Before, @After annotations.
Dependency Support: No built-in support for test dependencies
Parallel Execution: Not supported.
Parameterized Tests: Uses @RunWith(Parameterized.class).
Reporting: Basic reporting.
Test Execution Control: Runs tests alphabetically.

TestNG

Annotations: More powerful annotations that include @BeforeMethod, @AfterMethod. @DataProvider
Dependency Support: Supports dependencies using dependsOnMethods.
Parallel Execution: Supported using testng.xml.
Parameterized Tests: Uses @DataProvider (more flexible).
Reporting: Generates detailed HTML reports.
Test Execution Control: Runs based on priority using priority attribute.

51. What is an annotation in TestNG?

In TestNG, annotations are special markers (starting with @) that control the test execution flow. They define setup, teardown, test execution, and dependencies in a structured way.

Here is the list of common TestNG annotations with their usage.

@Test: Marks a method as a test case.
@BeforeMethod: Runs before each test method.
@AfterMethod: Runs after each test method.
@BeforeClass: Runs once before all test methods in a class.
@AfterClass: Runs once after all test methods in a class.
@DataProvider: Provides test data for data-driven testing.
@Parameters: Passes values from testng.xml to test cases.

52. What is a DataProvider in TestNG?

You can use @DataProvider in TestNG to perform data-driven testing. It allows the test method to run multiple times with different data sets. It helps in executing parameterized tests efficiently.

Here are key features:

You can use it to run the same test with multiple inputs.
Eliminates hardcoded test data in test scripts.
Can fetch data from Excel, CSV, or databases.

53. How do you use DataProvider to pass test data?

To use @DataProvider in Selenium test, follow the steps below.

Define a method with @DataProvider.
Return a 2D Object array containing test data.
Use @Test(dataProvider = "providerName") to link the test with the DataProvider.

Here is an example of how to pass test data using DataProvider.

Example: Passing Test Data Using DataProvider

import org.testng.annotations.*;

public class DataProviderExample {

    // Step 1: Define DataProvider
    @DataProvider(name = "loginData")
    public Object[][] getData() {
        return new Object[][] {
            {"user1", "pass1"},
            {"user2", "pass2"},
            {"user3", "pass3"}
        };
    }

    // Step 2: Use DataProvider in Test
    @Test(dataProvider = "loginData")
    public void testLogin(String username, String password) {
        System.out.println("Testing login with: " + username + " / " + password);
        // Add Selenium code to perform login here
    }
}

54. What is a TestNG XML file?

A TestNG XML file (testng.xml) is a configuration file. It is useful to organize and execute multiple test cases in a structured way. It allows:

To run multiple test classes together.
To group and prioritize test cases.
Parallel test execution.
To pass parameters to test methods.

Example: Basic TestNG XML File (testng.xml)

<suite name="TestSuite">
    <test name="LoginTest">
        <classes>
            <class name="tests.LoginTest"/>
        </classes>
    </test>
</suite>

How to Run Tests Using TestNG XML?

Right click on the testng.xml file.
Select "Run As → TestNG Suite" in Eclipse.

55. How do you run tests in parallel using TestNG?

TestNG allows parallel execution to speed up test runs by running multiple tests simultaneously. You can configure it in the testng.xml file using the parallel attribute.

Steps to Run Tests in Parallel:

Set parallel="methods" or parallel="classes" in testng.xml.
Define thread-count to control how many threads run at the same time.

Example: Parallel Execution of Test Methods (testng.xml)

<suite name="ParallelSuite" parallel="methods" thread-count="2">
    <test name="ParallelTest">
        <classes>
            <class name="tests.ParallelTest"/>
        </classes>
    </test>
</suite>

Java Example: Parallel Test Execution

import org.testng.annotations.Test;

public class ParallelTest {
    
    @Test
    public void testOne() {
        System.out.println("Test One - " + Thread.currentThread().getId());
    }

    @Test
    public void testTwo() {
        System.out.println("Test Two - " + Thread.currentThread().getId());
    }
}

56. What is the difference between soft assert and hard assert?

Difference between soft assert and hard assert is as below.

Hard Assert:

Stops Execution?: Yes, it stops execution once test fails and so assertion fails.
Multiple Assertions?: Not possible, as execution stops on failure.
Best For?: Critical validations like login success.

Soft Assert:

Stops Execution?: Execution will continue even if assertion fails.
Multiple Assertions?: Possible, as failures are collected and reported at the end.
Best For?: Non-critical checks (e.g., UI element verification).

57. How do you generate reports in TestNG?

TestNG has built-in features to generate HTML and XML reports after test execution. However, you can use IReporter or ITestListener to generate interactive custom reports.

Default TestNG Report (HTML & XML)

TestNG creates a report in the test-output folder once you run the test.
You can open test-output/index.html file in a browser to view the report.

Generating Custom Reports Using IReporter

You can implement IReporter to customize reports as below.

import org.testng.IReporter;
import org.testng.ISuite;
import org.testng.xml.XmlSuite;
import java.util.List;

public class CustomReport implements IReporter {
    public void generateReport(List<XmlSuite> xmlSuites, List<ISuite> suites, String outputDirectory) {
        System.out.println("Generating custom report...");
    }
}

Add to testng.xml:

<listeners>
    <listener class-name="reports.CustomReport"/>
</listeners>

Using ITestListener for Custom Logs

Capture test start, success, and failure logs.

import org.testng.ITestListener;
import org.testng.ITestResult;

public class TestListener implements ITestListener {
    public void onTestSuccess(ITestResult result) {
        System.out.println("Test Passed: " + result.getName());
    }
    
    public void onTestFailure(ITestResult result) {
        System.out.println("Test Failed: " + result.getName());
    }
}

Add to testng.xml:

<listeners>
    <listener class-name="listeners.TestListener"/>
</listeners>

58. What is Maven and how does it help in Selenium automation?

Maven is a build automation and dependency management tool for Java projects. You can use Maven to manage project dependencies. Also, it is useful to build and run selenium test cases efficiently.

How Maven Helps in Selenium Automation?

Manages Dependencies Automatically: No need to download JAR files manually.
Standard Project Structure: It follows a predefined structure. So it is easy to maintain a project.
Easier Test Execution: You can run tests using a simple command "mvn test".
Integration with CI/CD: You can integrate it easily with Jenkins, GitHub Actions, Azure DevOps for automation.
Parallel & Cross-Browser Testing: It is easy to configure TestNG for parallel execution using Maven.

59. What is a pom.xml file in Maven?

The pom.xml (Project Object Model) file is the core configuration file in a Maven project. It defines:

Project details (name, version, description).
Dependencies (e.g., Selenium, TestNG).
Plugins (e.g., Maven Surefire for running tests).
Build and execution commands.

How pom.xml Helps in Selenium?

Manages dependencies automatically: No need to download JARs manually.
Easy test execution: Run tests using mvn test.
Integrates with CI/CD: Works with Jenkins, GitHub Actions, etc.

60. How do you integrate Selenium with Maven?

You can integrate Maven with Selenium to simplify dependency management and test execution. You can follow these steps to set up a Selenium Maven project easily.

Steps to Integrate Selenium with Maven

Create a Maven Project

In Eclipse/IntelliJ: File → New → Maven Project → Select Quickstart Archetype.

Add Selenium & TestNG Dependencies in pom.xml

<dependencies>
    <!-- Selenium WebDriver -->
    <!-- https://mvnrepository.com/artifact/org.seleniumhq.selenium/selenium-java -->
	<dependency>
    		<groupId>org.seleniumhq.selenium</groupId>
    		<artifactId>selenium-java</artifactId>
    		<version>4.29.0</version>
	</dependency>


    <!-- TestNG -->
    <!-- https://mvnrepository.com/artifact/org.testng/testng -->
	<dependency>
    		<groupId>org.testng</groupId>
    		<artifactId>testng</artifactId>
    		<version>7.11.0</version>
    		<scope>test</scope>
	</dependency>

</dependencies>

Write a Sample Selenium Test (Java)

Create a test class in src/test/java

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.annotations.Test;

public class GoogleTest {
    @Test
    public void openGoogle() {
        WebDriver driver = new ChromeDriver();
        driver.get("https://www.google.com");
        System.out.println("Title: " + driver.getTitle());
        driver.quit();
    }
}

Run Tests Using Maven

Run all tests:

mvn test

General Tips From Experts for Answering Interview Questions

Here are some expert tips from The Muse, indeed, careers.govt.nz, and The Guardian articles on how to answer interview questions more precisely to get success.

Understand the Question – Ensure that you take a moment before answering the question and ask for clarification if needed.
Match Answers to the Company’s Needs: Research about the company and personalize your responses accordingly.
Stay Positive & Professional: Avoid insulting past employers and use challenges as a learning experience.
Here are a few expert tips from the Muse article
Use the STAR Method – For more clarity, organize your responses using Situation, Task, Action, and Result.
Be Concise and Relevant – Try to keep your answers under 2 minutes and avoid going into unnecessary detail.
Highlight Results & Impact: You can showcase your impacts using numbers and metrics, which makes your achievements clear, memorable, and results-driven.
Practice, But Don’t Memorize: Practice answering common questions while keeping the responses natural.

How to Download EdgeDriver for Selenium (Step-by-Step Guide)

noreply@blogger.com (Unknown) — Sat, 01 Mar 2025 11:12:00 +0000

You need EdgeDriver to run Selenium tests in Microsoft Edge browser. It lets Selenium WebDriver interact with MS Edge browser just like a real user.

Here is a step-by-step guide to download, install, and set up the right version of EdgeDriver.

Step 1: Check Your Microsoft Edge Version

Before downloading EdgeDriver, you must check your Edge browser version.

Here’s how to check:

Open Microsoft Edge.
Click the three dots (⋮) at the top right corner - Select Help and Feedback - Select About Microsoft Edge. My version is Version 133.0.3065.92.
Update if you are using an older version. Note the version number (e.g., 133.x.x.x).

Why does this matter?

Many people keep complaining that the edge driver is not working in Selenium. The reason is EdgeDriver version updates with a version of the Edge browser, and a mismatch in versions can generate errors when you run Selenium tests.

Now let’s see how to download the correct version of EdgeDriver.

Are you looking to run selenium tests in Firefox browser? Here is a step-by-step guide on how to download and set up GeckoDriver for Selenium.

Step 2: Download EdgeDriver For Selenium WebDriver

To download EdgeDriver, follow these simple steps:

Go to the official Microsoft Edge WebDriver page:
As per your Edge browser version and OS, download the corresponding EdgeDriver from the stable channel.

Now let's see how to set up the edge driver.

Step 3: Extract and Set Up EdgeDriver

Once downloaded, you need to extract the ZIP file.

Extract the EdgeDriver ZIP file to a location like D:\WebDriver\
Inside the folder, you’ll find msedgedriver.exe.

But to run EdgeDriver in your selenium tests, you need to add it to the system PATH.

Here’s how:

Search for Environment Variables in Windows.
Under System Variables, find Path and click Edit.
Click New, then paste your folder path (e.g., D:\WebDriver\).
Click OK and restart your computer.

Now, EdgeDriver is ready to run.

Step 4: Run EdgeDriver with Selenium

To make sure EdgeDriver is working, let’s write a quick Selenium test script. Use the given edge driver set up code in your selenium test and run it.

Example of Microsoft Edge Driver in Selenium

        // Set the path to EdgeDriver (only needed if it's not in system PATH)
        System.setProperty("webdriver.edge.driver", "D:\\WebDriver\\msedgedriver.exe");

        // Initialize EdgeDriver
        WebDriver driver = new EdgeDriver();

This example script will help you run the Selenium test on Microsoft Edge browser. Now, you can:

Open Edge automatically when running the Selenium test.
Navigate to websites.
Extract page titles & interact with web elements.

Tip: Always use the latest Selenium version and update EdgeDriver whenever Edge browser's version updates.

How to Download and Set Up GeckoDriver In Selenium (Step-by-Step Guide)

noreply@blogger.com (Unknown) — Sat, 01 Mar 2025 06:38:00 +0000

Are you looking to automate Firefox with Selenium WebDriver? You need GeckoDriver.

But many beginners struggle with setting it up correctly.

If that’s you, don’t worry.

Let's see how to download and use geckodriver in selenium test step by step.

What is GeckoDriver? (And Why Do You Need It?)

Simply put, GeckoDriver acts as a bridge between Selenium and Firefox. Without it, your automation test scripts will not work in the Firefox browser.

That is the reason you need to install it before running Selenium WebDriver with Java.

Now, let’s get started.

Step 1: Download GeckoDriver

This is the easy part.

Just follow these steps:

Make sure You have the latest version of the Firefox browser. My version is 135.0.1.
Go to the official GeckoDriver download page.
Download the latest version based on your operating system:

Windows: geckodriver-vx.x.x-win-aarch64.zip
Mac: geckodriver-vX.X.X-macos.tar.gz
Linux: geckodriver-vx.x.x-linux64.tar.gz
Extract the file to a known location on your system.
You will get geckodriver.exe file in the extracted folder.

Are you looking to run Selenium tests in Chrome browser? You can find a guide on how to download ChromeDriver for Selenium.

Done? Great! Now, let’s move on.

Step 2: Add GeckoDriver to System Path (Optional, But Recommended)

This step is optional, but it will help you avoid a lot of headaches later.

Why?

Because adding GeckoDriver to your system path means you won’t have to specify its location in every script.

Move geckodriver.exe to D:\geckodriver\ folder.
Add D:\geckodriver\ to System Environment Variables:

Search for "Environment Variables" in the Start menu.
Click Edit the system environment variables.
Under System Variables, find Path and click Edit.
Click New and add D:\geckodriver\
Click OK to save.

Do you know which other browsers and languages are supported by Selenium? Here is a list of browsers and programming languages supported by Selenium WebDriver.

Step 3: Write Java Code to Launch Firefox

Let’s put GeckoDriver to the test.

Here’s a simple Java program to launch Firefox with Selenium:

        WebDriver driver = new FirefoxDriver();
        driver.get("https://only-testing-blog.blogspot.com/");        
    driver.close();

Troubleshooting: Fixing Common Errors

Still running into issues? Let’s fix them.

Error: ‘geckodriver’ is not recognized as an internal or external command.

Fix: Make sure GeckoDriver is added to your system’s PATH.

Error: WebDriverException: Message: geckodriver executable needs to be in PATH

Fix: Double-check that GeckoDriver is accessible from your terminal.

Error: SessionNotCreatedException: This version of Firefox is not supported

Fix: Update both GeckoDriver and Firefox to the latest versions.

You did it!

By following this guide, you’ve successfully:

Downloaded GeckoDriver
Configured it for Java and Selenium.
Written and executed a Selenium script for Firefox.

Now, you’re all set to automate selenium tests in Firefox browser.

Selenium WebDriver: Compact & Concise Web Browser Automation API

noreply@blogger.com (Unknown) — Thu, 27 Feb 2025 11:47:00 +0000

Selenium WebDriver is a popular & widely used web browser automation tool that automates web application testing in all major browsers and operating systems. This remote-control open-source API allows you to create and execute automation tests natively in browsers using multiple supported programming languages.

History of Selenium WebDriver

Selenium and WebDriver were created by distinct individuals, but in the end, they became one powerful automation tool.

Before moving ahead, we should quickly examine the history of Selenium and WebDriver's development.

Selenium:

Development:

Initially, Selenium was designed and developed by Jason Huggins in 2004 when he was working at ThoughtWorks in Chicago.

Primarily, he developed it to automate web application testing.

Later on, Paul Hammant, Aslak Hellesoy, Mike Melia, Aslak, and Obie Fernandez joined him.

They worked collectively to develop and improve different components of Selenium, like the server and client driver, and make it an open source framework.

Problem:

The initial version of Selenium (RC) was heavy due to its reliance on the proxy server and JavaScript injection to automate tests for web browsers.

WebDriver

Development:

Around 2007, Simon Stewart came up with the WebDriver API, which uses separate clients for each browser.

Compared to Selenium RC, it was lighter and easier to use.

In 2008, they made the decision to combine both projects. This merger brought the best of both worlds: Selenium’s flexibility and WebDriver’s native browser control.

(Source)

From 05 June 2018, it is a W3C-recommended browser automation testing tool.

How Does WebDriver Work?

At its core, Selenium WebDriver is like a remote control for your web browser. It directly communicates with the browser and executes actions. Let's see how WebDriver works step by step.

1. Test Script (Your Code)

You can write a WebDriver automation test script in your preferred language like Java, Python, C#, JavaScript, etc. You will learn all supported languages by WebDriver in the upcoming section of this article.

These scripts contain:

Command to open a browser.
Instructions to click buttons, fill out forms, or extract text.
Assertions to verify expected results.

2. WebDriver API (Middleman)

Selenium WebDriver serves as a bridge between your code and the browser when your test script communicates with it.

3. Browser Driver (Translator)

Each browser has a dedicated WebDriver (ChromeDriver, GeckoDriver, etc.).

WebDriver sends your test commands to the browser driver.
The browser driver translates them into native browser actions.

In the upcoming section, You will learn about WebDriver-supported drivers.

4. Browser Execution

The browser driver controls the browser directly and performs actions like:

Clicking buttons
Typing in fields
Navigating between pages
Taking screenshots

5. Response Back to the Test Script

After executing commands, the browser sends a response back to WebDriver.
WebDriver then sends results to your test script (pass/fail, error messages, etc.).

And that’s how Selenium WebDriver automates your browser like a pro!

WebDriver-Supported Browsers, Languages

Browsers

WebDriver can directly talk to the browser through automation drivers. Selenium WebDriver-supported browser drivers are:

ChromeDriver for Google Chrome (OS Support: Windows/Linux/macOS)

Steps to download and set up chromedriver for Selenium

GeckoDriver for Mozilla Firefox (OS Support: Windows/Linux/macOS)

Steps to download and set up GeckoDriver for Selenium

EdgeDriver for Microsoft Edge (OS Support: Windows/Linux/macOS)

Steps to download and install EdgeDriver for Selenium

SafariDriver for Apple Safari browser (OS Support: Mac-only)
InternetExplorerDriver for Internet Explorer (OS Support: Windows. Legacy support)
OperaDriver For Opera (Discontinued, but still you can use WebDriverManager)

Why does this matter?

Cross-Browser Testing: You can make sure that your website works smoothly in different browsers.
User Experience: Pages are rendered differently by different browsers.
Market Coverage: Accessibility can be ensured by testing on multiple browsers due to user preferences.
Bug Detection: Some issues only appear in specific browsers. You can find those hidden bugs early!

Languages

Selenium WebDriver supports multiple programming languages, including:

Java: Most widely used, strong community support.
Python: Easy syntax, great for beginners & automation scripts.
C#: Popular for .NET developers & enterprise applications.
JavaScript: Ideal for web apps, works well with Node.js.
Ruby: Simple syntax, great for quick scripting.
PHP: Preferred for PHP developers to perform server-side web automation.
Perl: Older but still useful for legacy automation.

Are you confused which language to use? Here is a detailed guide on Selenium supported languages and which best suits you.

Why Does This Matter?

Flexibility: You can write tests in the language your team already uses.
Integration: Works seamlessly with different tech platforms and frameworks like JUnit, TestNG, PyTest, NUnit, Mocha, etc.
Wider Adoption: More developers can contribute without learning a new language.
Scalability: Supports various development environments (backend, frontend, mobile, etc.).

Locators

Selenium WebDriver supports multiple locators as below.

Pros and Cons of Selenium WebDriver

First of all, let's look at the advantages/benefits of Selenium WebDriver.

Pros:

Supports Multiple Programming Languages: You can work with your preferred language like Java, Python, C#, JavaScript, Ruby, PHP, and Perl.
Supports Cross-Browser Testing: You can run your test scripts in Chrome, Firefox, Edge, Safari, Opera, and IE browsers.
Supports Cross-Platform Testing: You can run WebDriver tests across multiple operating systems like Windows, Mac, and Linux.
Open-Source & Free: No licensing costs.
Works with Real Browsers: You can perform accurate testing with a real browser as it interacts directly with it.
Integrates with Popular Testing Frameworks: Works seamlessly with JUnit, TestNG, PyTest, NUnit, etc. for structured test execution.
Supports Parallel & Remote Testing: With Selenium Grid, you can run tests on multiple machines & browsers at once.
Extensive Community & Resources: It is being used by a significant amount of developers and testers. You can quickly find solutions on online forums and Selenium community websites.

Cons:

Here are the disadvantages/limitations of Selenium WebDriver

No Built-in Reporting: You need third-party tools like ExtentReports, Allure, and TestNG to generate test reports.
Steep Learning Curve for Beginners: Requires coding knowledge; not as beginner-friendly as codeless testing tools like TestProject or Katalon.
Limited Support for Desktop & Mobile Apps: Primarily, it is developed for web application testing only. You can use Appium for mobile testing and WinAppDriver to test desktop apps.
Handling Dynamic Elements Can Be Tricky: Websites using AJAX, dynamic DOM changes, or animations might require explicit waits and extra handling.
Can Be Slow Compared to Headless Testing Tools: Since it interacts directly with actual browsers, tests might run slower compared to tools like Cypress (which runs in a JavaScript engine).

In Summary, It is best for web automation, cross-browser testing, and open-source flexibility. However, it is not ideal for beginners, desktop apps, or advanced reporting without extra tools.

Despite challenges, Selenium WebDriver remains one of the most effective automation tools available today!

Alternatives of Selenium WebDriver

Despite technological advancements, Selenium WebDriver remains one of the best web application automation testing tools by 2025. However, other options may be more advantageous depending on your requirements. Here are some alternatives to consider:

1. Cypress (Best for JavaScript & Frontend Testing)

Why Use It?

Faster execution (runs inside the browser, unlike Selenium).
Easy setup with Node.js.
Better debugging with real-time reloading.
Built-in screenshot & video recording.

Limitations:

Only supports JavaScript.
Works mainly for front-end testing (not for cross-browser automation).

2. Playwright (Best for Modern Browser Automation)

Why Use It?

Supports multiple languages (JavaScript, Python, C#, Java, TypeScript).
Works with multiple browsers (Chromium, Firefox, WebKit).
Handles auto-waiting & retries (better for dynamic pages).
Headless mode for faster execution.

Limitations:

Newer tool. less community support compared to Selenium.

Why Use It?

Built for Google Chrome & Chromium automation.
Great for web scraping & PDF generation.
Fast execution with headless mode.

Limitations:

Works only with Chrome browser (not a true cross-browser tool).
Requires Node.js & JavaScript knowledge so not beginner friendly.

Selenium WebDriver remains one of the best tools for cross-browser automation, web testing, and scalability. While it has some limitations, its flexibility, large community, and open-source nature make it a top choice for automation testers in 2025!

Apache JMeter: Load and Performance Testing Made Simple

noreply@blogger.com (Unknown) — Thu, 09 Jan 2025 17:00:00 +0000

Introduction: Load and Performance Testing Using Apache JMeter

The performance, reliability, and usability of your software application are crucial factors in today's fast-paced, competitive digital world. It is crucial to check how your application performs during both regular and peak usage since users expect a smooth and reliable experience when visiting and navigating your website. This is where load and performance testing using Apache JMeter comes into play.

Using JMeter for testing, testers, and developers can identify performance-related potential bottlenecks that cause the issue. Whether you’re conducting Apache JMeter load testing to evaluate server stability or JMeter performance testing to measure response times, JMeter software provides a complete understanding of your application’s behavior under different conditions, as it can simulate real-world traffic, making it an invaluable tool for developers and testers.

What is Apache JMeter software?

Apache JMeter is a powerful and widely used open-source tool that is designed by the Apache Software Foundation to perform load and performance testing of software applications. It has a wide variety of robust features and a user-friendly interface that helps developers analyze the performance and scalability of web applications, APIs (application programming interfaces), databases, and many more.

JMeter for testing allows you to simulate heavy loads on a server, group of servers, or network to assess the performance of an application under different traffic conditions. You can analyze server behavior and performance under different states of load conditions.

Key Features and Benefits of Apache JMeter in Software Testing

Here is the list of key features of Apache JMeter software:

Protocol Support: Apache JMeter supports a variety of protocols for testing as below.

Web: Protocols to test HTTP and HTTPS requests.
SOAP/REST: Protocol to test web services.
FTP: Network protocol
JDBC: Java API to connect and execute queries in a database.
LDAP: Lightweight Directory Access Protocol.
Message-oriented middleware (MOM) via JMS API.
Mail: SMTP, POP3, and IMAP protocols.
TCP: Transmission Control Protocol
Java Objects

Scalability: You can perform stress testing using It by simulating thousands of users to measure the performance of the application and how it can handle growth.
Extensibility: It supports a wide variety of plugins, like custom thread groups, throughput shaping timers, PerfMon servers, performance monitoring, etc., to enhance the capability of JMeter software to meet specific testing needs.
User-Friendly Interface: It provides a graphical user-friendly interface to perform load and performance testing.
Record & Playback: You can record your browser activities in it. Also, you can play back those navigations in your JMeter load testing plan.
Distributed testing: You can distribute a virtual user's load on different systems using the master-slave architecture that is provided by JMeter.
Reporting: You can generate different kinds of graphical reports in the form of graphs, charts, tables, and HTML in the JMeter performance testing tool to identify bottlenecks and optimize performance.
Assertions: You can compare and validate expected and actual responses of the server using assertions in JMeter. Response Assertion, Duration Assertion, BeanShell Assertion, and Size Assertion are a few examples of assertions in Apache JMeter.
CI/CD Integration: It can be integrated with CI/CD tools like Jenkins, GitLab, and many more to streamline performance testing and ensure higher software quality.
Platform independent: It can run on different platforms and OS as it is a pure 100% Java-based application.
Community support: Apache JMeter has vast online community support to find any solution and support.

All these are the key features of jmeter in software testing. These versatile and easy-to-use features of the Apache JMeter load testing tool make JMeter popular in the software testing industry.

Load And Performance Testing Using Apache JMeter

Before learning about Apache JMeter load testing and JMeter performance testing, You must know the difference between load and performance testing in software testing.

Difference Between Load and Performance Testing

What is Performance Testing?

Performance testing is a practice that evaluates a system's responsiveness and stability under specific workload conditions. It evaluates the overall efficiency and responsiveness of a system under varying conditions.

Example: Giving your car a complete checkup - checking everything from acceleration and handling to fuel efficiency.

What is Apache JMeter Performance Testing?

It examines the system's speed, stability, and responsiveness under various conditions, including normal and stress scenarios, to ensure optimal performance.

The Goal of JMeter Performance Testing

Measure response times and throughput for critical transactions.
Identify system stability under prolonged usage.
Detect performance issues like latency, memory leaks, or crashes.

Example of Performance Testing: You have a JMeter performance test scenario for an e-commerce site to simulate users performing different actions like Registration, login, Navigating to the About us page, Adding product to basket and checkout, and contact us form submission. JMeter can be used to test how quickly a web page loads, how many transactions can be processed per second, and whether the application maintains its reliability over time.

What is Load Testing?

Load testing involves simulating multiple users accessing a software program simultaneously to evaluate its performance. Load testing focuses on assessing how an application performs under varying levels of user traffic and increasing loads.

Example: Test how your car handles behaves when it's fully loaded with passengers and cargo.

What is Apache JMeter Load Testing?

It focuses on evaluating how a system behaves under concurrent expected or high user load to identify its capacity and scalability.

The Goal of JMeter Load Testing

Identify the maximum number of users the system can handle without performance degradation.
Evaluate the application’s response time under normal and peak loads.
Detect bottlenecks that might arise due to high user activity.

Example of Load Testing: You have a JMeter load test scenario for an e-commerce site to simulate users performing different actions like registration, login, product addition to basket, and checkout. JMeter can simulate users performing different actions and provides you a matrix to analyze application load capacity and based on that you can improve it.

Different Types of Performance Testing in Software Testing

You can use JMeter to perform different types of performance testing. Let us see what types of performance testing we can do using JMeter.

Load Testing: Already discussed above.

Volume Testing:

The main objective of volume testing in software testing is to check how well a software application works when dealing with a large amount of data. This testing helps to see how the application behaves when there is a lot of data stored in its database. It also helps find problems like system failures, slowdowns, or inefficiencies caused by handling too much data in a database or file system.

Example of Volume Testing:

Online ticket booking systems or banking systems process millions of transactions every hour. You can simulate these transaction datasets to analyze the system's performance in processing a large volume of data. You can use automation tools like JMeter to perform volume testing.

Stress Testing:

The main goal of stress testing in software testing is to observe the system's behavior in extreme workload conditions with limited resources. You can identify the system's workload limitations and breaking or weak points when sudden spikes in user traffic, low memory or CPU, or large data processing in a short time.

Example of Stress Testing

You can consider Netflix's global event scenario where lakhs of users start watching online streaming suddenly. You can use this scenario to simulate a sudden spike in users and observe how much stress the system can handle. You can use automation tools like Apache JMeter or LoadRunner to perform stress testing.

Scalability Testing:

Software scalability testing determines whether the system can scale up automatically when a user's traffic or transactions increase without compromising performance or stability. It identifies resource limits and performance bottlenecks and you can plan capacity additions accordingly

Example of Scalability Testing:

E-commerce sites get a large volume of users and transactions during the festival season like the Black Friday sale. You can simulate this scenario using automation tools like Apache JMeter to perform scalability testing. You can gradually increase the user base to determine the system's scalability and performance.

Spike Testing:

Spike testing in software testing is a type of performance testing to analyze a system's performance on the sudden spike of users and how well it can recover once the spike is reduced. It can identify the system's weakness during sudden workload changes.

Example of Spike Testing:

Online ticket booking system when tickets for a football or cricket go on sale before the World Cup. You can simulate this scenario to perform spike testing using automation tools like LoadRunner or Apache JMeter.

Soak Testing:

Soak testing in software testing is known as Endurance Testing used to determine a system's performance under a sustained load over an extended period. It identifies the system's stability under normal or peak load conditions over long periods.

Example of Soak Testing:

You can consider a banking system scenario to simulate steady user transactions over a week using performance testing tools like Apache JMeter or LoadRunner.

Perform Load And Performance Testing in Apache JMeter

To perform Apache JMeter load testing, First of all, you need to check which Java version is installed on your system. It should be Java 8+.

Step 1. Check Java Version in Windows

Type "java -version" in the command prompt.

Install or update the Java version if you do not have Java 8+ in your system.

Step 2. Download Apache JMeter Software

To use it for testing, download the latest version of Apache JMeter software. Here is a step-by-step guide to downloading and installing jmeter.

To download JMeter, Open JMeter Download Link
Download the Zip file from the Binaries section and save it in your local drive.

Extract the downloaded JMeter folder.

You do not need to install JMeter. You can run the jmeter.bat file from the downloaded jmeter folder to open the JMeter Interface.

Step 3. Initiate JMeter For Testing

Open the bin folder. You will find it inside the extracted folder.

Double-click on the "jmeter.bat" file. It will initiate the it's interface.
Hold on. It can take some time to initiate the interface.

Step 4: Create First Load Testing Plan in Apache JMeter

Now you are all set to create the first JMeter load or performance testing plan. We will create a sample test plan by adding different essential components. Here is a step-by-step guide to creating a sample test plan in Apache JMeter.

Create a New Test Plan

In the interface, Navigate and click File -> New.

Rename the test plan to "Sample Test" and click on the save button to save it at your desired location in local drives.

Add Thread Group in Apache JMeter Test Plan

What is Thread Group in JMeter?

It is group control in Apache JMeter. You can specify how many number of threads you want to use to execute your Apache JMeter load test. Also, you can set the Ramp-up period and loop count in a thread group.

Right-click on JMeter "Sample Test" plan and click on Add -> Threads (Users) -> Thread Group.

It will add a thread group under the sample test plan.

Configure Thread Group Elements

You need to configure the thread group to run the test with concurrent users.
Select Thread Group from the tree and set

Number of Threads (users) = 5
Ramp-up period (seconds) = 5
Loop Count = 1

This configuration will load 5 concurrent users in 5 seconds when you run the test.
Save the test plan.

Add HTTP Request in Apache JMeter Performance Testing Plan

What is HTTP Request in Apache JMeter?

HTTP Request is a sampler in Apache JMeter. It can send HTTP or HTTPS requests to the server.

Right-click on Thread Group and select Add -> Sampler -> HTTP Request.
It will add an HTTP Request under Thread Group.

Configure HTTP Request Elements

Select HTTP Request from the tree and set

Name = Home Page
Server Name or IP = Paste your website to test URL without HTTP/HTTPS

Example: If your site URL is https://www.yoursitename.com/ then use only www.yoursitename.com
Path = /

Save the test plan.

You can add multiple requests as well under the thread group to execute all of them simultaneously.

Add Listeners in Apache JMeter Load Testing Plan

What is Listeners in Apache JMeter?

Listeners are used to displaying the results of your jmeter performance tests. There are different types of listeners available in Apache JMeter. You can add them as per your requirements.

Right-click on Thread Group -> Add -> Listener -> View Results Tree.
Right-click on Thread Group -> Add -> Listener -> Summary Report.
It will add both listeners under the test plan tree.
Save sample load testing plan.

You can add any other samplers as well as per your testing requirement.

Now sample performance test plan is ready to run.

Step 5: Run Apache Jmeter Sample Load Test Plan

Now you can Run your sample test plan.

You can Run a test plan by

Clicking on the Start button or
Selecting menu Run -> Start.

Our sample test plan will be executed with 5 concurrent threads (users) as per our Thread group configuration. It will loan 1 thread per second. Select View Result Tree listener during test execution to see how users are loaded to execute requests. You can increase the number of threads or Ramp up the period as per your requirement for more clarity.

Step 6: View Test Results

Load test results will be displayed in Listeners. You can view results by selecting both listeners one by one as below.

Conclusion

Apache JMeter is a powerful, open-source tool that simplifies load and performance testing for businesses. As a cornerstone in software testing, JMeter empowers organizations to ensure their applications are reliable, efficient, and scalable under various conditions. Its features make JMeter software ideal for detecting performance bottlenecks, enhancing user experience, and maintaining system stability. By using JMeter for testing, businesses can gain valuable insights into optimizing performance. Whether focusing on Apache JMeter load testing to handle user traffic or JMeter performance testing to ensure speed and reliability, this versatile tool is a must-have for successful application development and maintenance.

Getsize In Selenium

noreply@blogger.com (Unknown) — Tue, 06 Dec 2022 04:30:00 +0000

Selenium getSize() method

You can get the browser window size using getSize() method in selenium. It will be helpful to get the current working window size(height & width) in selenium test execution if required.

getSize() method in selenium is part of WebDriver.Window interface.
It is used when you want to get current working window dimensions.
It will return height and width of current working browser window.
Syntax : driver.manage().window().getSize();

Let us see how getSize() method works to get browser window dimension with example.

Selenium getSize() method example to get window size

package testPackage;

import org.openqa.selenium.Dimension;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class getsizeExample{

	public static void main(String[] args) {
				
		System.setProperty("webdriver.chrome.driver", "D:\\chromedriver.exe");
		WebDriver driver=new ChromeDriver();		
		//Get current window size dimension and print it in console.	
		Dimension size = driver.manage().window().getSize();
		System.out.println(size);
	}
}

In above given example, getsize() method will return height and width of current launched window and it will print it in console.

Selenium Set Window Size

noreply@blogger.com (Unknown) — Tue, 06 Dec 2022 03:43:00 +0000

Set browser window size in selenium

Selenium has built in method to set size of browser window. You can use setSize() method to set the browser window size during your selenium test execution. This method is useful when you want to resize the browser window as per your selenium test requirement.

setSize() method is part of WebDriver.Window interface.
This method's return type is void.
You can provide the size of window to set set size of current working window in selenium test.
Syntax : driver.manage().window().setSize(new Dimension(w, h));
It will set window size as per the given dimension.

Let us implement this method practically to see how it works.

setSize() example in selenium

package testPackage;

import org.openqa.selenium.Dimension;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class setsizeExample{

	public static void main(String[] args) {
				
		System.setProperty("webdriver.chrome.driver", "D:\\chromedriver.exe");
		WebDriver driver=new ChromeDriver();		
		//Set size of browser window as per given dimensions.	
		driver.manage().window().setSize(new Dimension(1250, 600));
		driver.navigate().to("http://only-testing-blog.blogspot.com/2013/09/testing.html");
	}
}

If you look at above given example, We have provided window size dimension to 1250 X 600. It will set browser window size as per provided dimensions.

Selenium Window Full Screen

noreply@blogger.com (Unknown) — Mon, 05 Dec 2022 09:31:00 +0000

Full Screen Window In Selenium

Selenium fullscreen() method is used to full screen the browser window. It will perform browser full screen action same as real user full screen the browser window. May be sometimes you need full screen window in your selenium tests at that time this method will be very useful for you.

fullscreen() method is part of WebDriver.Window interface.
It's return type is void so it returns nothing.
It will full screen the browser window.
Syntax : driver.manage().window().fullscreen();

Below given example will show you how fullscreen() method is used to full screen the window size.

Selenium fullscreen() method example

package testPackage;

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class fullscreenExample{

	public static void main(String[] args) {
				
		System.setProperty("webdriver.chrome.driver", "D:\\chromedriver.exe");
		WebDriver driver=new ChromeDriver();		
		driver.navigate().to("http://only-testing-blog.blogspot.com/2013/09/testing.html");
		//Fullscreen the browser window.	
		driver.manage().window().fullscreen();		
	}
}

In above given example, fullscreen() method will resize the window size to full screen.

Selenium Minimize Window Of Browser

noreply@blogger.com (Unknown) — Mon, 05 Dec 2022 05:33:00 +0000

Minimize window in selenium

Selenium 4 has built in method to minimize the browser window. It is less used method in selenium but still you can use it if you want to minimize window in between selenium test. minimize() method will perform browser minimize user action. You can run your selenium tests in minimized browser mode and you can perform your other tasks beside.

minimize() method is part of WebDriver.Window method.
This method will return nothing because it's return type is void.
It will minimize the current working window if it is not already minimized.
It is helpful when your are performing manual testing or any other work as your selenium tests will be executed in minimized mode.
Syntax : driver.manage().window().maximize();

Let us see practical example of using minimize() method in selenium.

Selenium minimize() method example

package testPackage;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class maximizewindowExample {

	public static void main(String[] args) {
				
		System.setProperty("webdriver.chrome.driver", "D:\\chromedriver.exe");
		WebDriver driver=new ChromeDriver();
		//Minimize the browser window.		
		driver.manage().window().minimize();
		
		driver.navigate().to("http://only-testing-blog.blogspot.com/2013/09/testing.html");
		driver.findElement(By.xpath("//span[normalize-space()='Test Link']")).click();
		driver.manage().window().maximize();
	}
}

In above given example, minimize() method will minimize the chrome browser window.

Selenium Maximize Window Of Browser

noreply@blogger.com (Unknown) — Mon, 05 Dec 2022 04:10:00 +0000

Maximize window in selenium

You can maximize window in selenium using maximize() method. Every time you launch browser in selenium test, It will open browser window in small size. So maximize() is most commonly used method in selenium test scripts. Maximize() method works same as user click on browser maximize icon to maximize the window. Selenium test scripts can be run without maximizing windows as well but it is good practice to maximizing browser windows before running the tests on page.

Maximize() method in selenium is part of WebDriver.Window interface.
It's return type is void.
It will maximize the current working browser window if it is not already maximized.
This method is generally used just after launching the browser window in selenium test script.
Syntax : driver.manage().window().maximize();

Let us see practical example to maximize the browser window in selenium test.

Selenium window maximize() example

package testPackage;

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class maximizewindowExample {

	public static void main(String[] args) {
				
		System.setProperty("webdriver.chrome.driver", "D:\\chromedriver.exe");
		WebDriver driver=new ChromeDriver();
		//Maximize the browser window.
		driver.manage().window().maximize();
		
		driver.navigate().to("http://only-testing-blog.blogspot.com/2013/09/testing.html");
	}
}

In above given example, we have used maximize() method after launching the browser. So initially browser will be launched and then maximize() method will maximize the browser window.

Selenium get url using getCurrentUrl()

noreply@blogger.com (Unknown) — Fri, 02 Dec 2022 10:20:00 +0000

Get url in selenium using getCurrentUrl() Method

Sometimes you need to get the current url during selenium test. You can get the URL of current open page using getCurrentUrl() method in selenium.

getCurrentUrl() method is part of WebDriver interface which extends SearchContext interface.
It will fetch the url from current open page in browser.
It will return rul as a string.
Syntax to use getCurrentUrl() : driver.getCurrentUrl().

Below given example will show you how to get url of current open page using getCurrentUrl() method in selenium.

Selenium getCurrentUrl() method example

package testPackage;

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class getCurrentUrlExample {

	public static void main(String[] args) {
				
		System.setProperty("webdriver.chrome.driver", "D:\\chromedriver.exe");
		WebDriver driver=new ChromeDriver();
		
		driver.navigate().to("http://only-testing-blog.blogspot.com/2013/09/testing.html");
		
		//Get current url of page and print it in console.
		String url = driver.getCurrentUrl();
		System.out.println("Current URL is : "+url);
	}
}

In above given example, getCurrentUrl() method will fetch url string of page and print it in console.

Selenium close browser

noreply@blogger.com (Unknown) — Thu, 01 Dec 2022 11:08:00 +0000

Close browser in selenium using close() method

To close browser in selenium, You can use close() method. It is used to close current open window on which selenium test is being executed.

close() method is part of WebDriver interface which extends SearchContext interface.
close() method in selenium will close only current selected window.
If multiple browser windows are open in selenium test then all windows will be not closed using close() method.
Syntax for using close() method is driver.close();

Selenium close() method example

package testPackage;

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class getTitleExample {

	public static void main(String[] args) {
				
		System.setProperty("webdriver.chrome.driver", "D:\\chromedriver.exe");
		WebDriver driver=new ChromeDriver();
		
		driver.navigate().to("http://only-testing-blog.blogspot.com/2013/09/testing.html");
		
		//close current running driver instance.		
		driver.close();		
	}
}

In above given example, close() method will close the current running driver window.

Selenium getTitle() method to get title of page

noreply@blogger.com (Unknown) — Thu, 01 Dec 2022 03:54:00 +0000

Selenium get title using getTitle() method

If you view source of page, You will find title of the page inside <title> and </title> tags. Selenium getTitle() method is useful to get the title of the page. You can verify or assert that title in selenium test case to check if targeted page is open or not.

getTitle() method is part of WebDriver interface which extends SearchContext interface.
It will return title of the web page if title is available for page.
It will return null string if title of the page is missing.
Syntax to get title : driver.getTitle();

Example of selenium getTitle() method

In below given example, We will open test site page and get the title. We will print that title in console.

package testPackage;

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class getTitleExample {

	public static void main(String[] args) {
				
		System.setProperty("webdriver.chrome.driver", "D:\\chromedriver.exe");
		WebDriver driver=new ChromeDriver();
		
		driver.navigate().to("http://www.only-testing-blog.blogspot.com");
		
		//Get the title of page and print it in console.
		String pageTitle = driver.getTitle();
		System.out.println("Page title is : "+pageTitle);	
	}
}

In console, It will print the title of the web page.

Selenium get attribute to get value of attribute

noreply@blogger.com (Unknown) — Wed, 30 Nov 2022 06:06:00 +0000

Selenium getAttribute() method

You can get value of attribute using getAttribute() method in selenium. As you know, all the web elements have one to many attributes. Sometimes you need to get it's value in selenium test to use it somewhere. At that time, selenium's build in getAttribute method will help to get value of that specific attribute.

getAttribute() method is part of WebElement interface which extends SearchContext and TakesScreenshot interfaces.
getAttribute() method is used to get value of that specific attribute of an element.
It will return value of attribute if attribute found.
It will return empty string if attribute not found.
Syntax for getAttribute() method : driver.findElement(By.Element_locator).getAttribute(Attribute_name);

In order to get value of element's attribute, First of all you need to locate that element. Then you can provide name of attribute inside getAttribute method to get it's value. Let us see it with practical example.

getAttribute() method example

In above given image, element Grand Parent1 have total 3 attributes id, name and type. We will locate that element by id and then try to get it's name and type attribute's values.

package testPackage;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

public class ClearExample {

	public static void main(String[] args) {
		
		System.setProperty("webdriver.chrome.driver", "D:\\chromedriver.exe");
		WebDriver driver=new ChromeDriver();
	    		
	    driver.get("http://only-testing-blog.blogspot.com/2022/11/relationship.html");
		
		//Find and locate textbox element by id.
		WebElement gp = driver.findElement(By.id("gparent_1"));
		
		//Get value of name attribute and print it in console.
		String name_Attr = gp.getAttribute("name");
		System.out.println("Name attribute value = "+name_Attr);
		
		//Get value of type attribute and print it in console.
		String type_Attr = gp.getAttribute("type");
		System.out.println("Type attribute value = "+type_Attr);
		
		//Get value of class attribute and print it in console.
		String class_Attr = gp.getAttribute("class");		
		System.out.println("class attribute value = "+class_Attr);	
	}
}

In above given example, We located element by id. Then get attribute values of name, type, class and then print it in console. It will return values of name and type attributes. Value of class attribute will be null because that attribute is not available on element.