How to Use Breakpoints for Debugging in Selenium WebDriver

What Is Debugging?

Debugging is a process that involves a deep inspection of the source code. For example, the code execution failed, or there is a need to take a deep dive into the framework code to understand execution steps in a much better way.

In the first stage of debugging, we have to identify and understand the issue or failure in the code. This would help us perform root cause analysis, which is one of the key skills of a tester or developer. If one has identified the issue and understood its root cause, it would be easier to develop an approach to resolve the issue.

Now comes the second stage, where we have to isolate the portion of the code on which debugging has to be performed. However, debugging every line of code is only necessary if required. Therefore, we have to separate the faulty code into smaller chunks and perform debugging.

Then, by understanding the cause of the failure, a fix can be provided to the buggy code, which can be finally reviewed and merged.

What are Breakpoints in Selenium WebDriver?

The breakpoints in Selenium lets you temporarily pause (or stop) the execution of the code. A breakpoint is added before a single or multiple lines in the code. By setting or inserting a breakpoint, the code will be executed up to the breakpoint, and the execution will halt once the breakpoint is encountered.

When the test script reaches the breakpoint, it enters the debugging mode, allowing the developer to inspect the minute details of the code and step deeper into the code to debug and troubleshoot the issue.

When debugging in Selenium WebDriver, breakpoints should be inserted at appropriate places to check the required variable values (and other details) in detail. Whether using the Eclipse IDE or IntelliJ IDE, breakpoints are shown alongside the UI.

Debugging in Selenium WebDriver With Eclipse

Let’s see how to insert a breakpoint in Eclipse IDE for debugging in Selenium WebDriver.

• Perform a right-click in the left side margin and click the Toggle Breakpoint option.

• Move to the line where you need to insert the breakpoint, click the Run menu, and click the Toggle Breakpoint option.

This way, you can add multiple breakpoints in your code. Once the breakpoint is added, you will see a blue circle on the left margin where you tried to insert the breakpoint.

Now that the breakpoint is added to the source code, it’s time to debug the issue.

Before running the code, we have to switch to the Debug perspective. To do this, navigate to the Windows menu → Perspective → Open Perspective.

Here, choose the Debug option.

To run the code, select the Java class, which has to run in debug mode. Next, right-click on the class, move to Debug As an option, and click Java Application.

If you haven’t switched to the Debug perspective view before running the code, you will get a switch notification prompting you to switch to the Debug perspective before running the code. Click Switch.

Now, the code starts running in debug mode.

The code will be executed and stop when it reaches the line where the breakpoint has been added. For example, in my code, I have added breakpoints in lines 39, 40, 41, 42, and 45. So, while running the code, the execution stops at line 39, as it is the first breakpoint in the code, and then moves ahead one by one.

When the breakpoint has been reached, it will be highlighted, as shown in the below screenshot.

Once the execution starts, you can see a window that shows the variables, Breakpoints, and Expressions tab.

The Breakpoints tab shows the lines in which the breakpoint has been added. For example, this shows that the breakpoint has been added in lines 39, 40, 41, 42, and 45 in the Java class brokenLinksCount.

The Variables tab shows the values being assigned to the variables in the line where the breakpoint has been added.

To control the execution, we have various shortcut keys in the editor. You can see them under the Run menu.

You can also view them in the submenu bar.

Let us understand their usage:

• Step Into (F5): The line where the breakpoint has been added will be executed, followed by the next lines. For example, if the breakpoint has been added to a method, the control reaches inside the method and debugs the code written within that method.

  Sometimes, the control might reach deep into the libraries and JDK classes, which could be skipped by checking the Use Step Filters option.


• Step Over (F6): When the control reaches the method where the breakpoint has been added, it steps to the next line after the method without getting into the method.
• Step Return (F7): The control returns to the caller of the method once the breakpoint inserted in the method is executed.
• Resume (F8): The code is executed until the control reaches the next breakpoint.
• Terminate (Ctrl+F2): This is used to terminate the debugging or execution of the code forcibly.
• Skip All Breakpoints (Ctrl+Alt+B): This is used to skip all the breakpoints inserted in the code.

Debugging in Selenium WebDriver With IntelliJ

Let’s see how to insert a breakpoint in IntelliJ IDE for debugging in Selenium WebDriver.

• Move to the line in which the breakpoint has to be added. Then, navigate to the Run → Toggle Breakpoint → click Line Breakpoint.

Debugging in Selenium WebDriver on the Cloud

• Navigate to the TestMu AI eCommerce Playground.
• Click on the Shop by Category menu.
• Check all the broken links in the Shop by Category menu.
• Use breakpoints to debug the test scripts and find the broken links.

public class SeleniumECommerceTests{

   private RemoteWebDriver driver;
   // ...

}

public ChromeOptions getChromeOptions() {
   final var browserOptions = new ChromeOptions();
   browserOptions.setPlatformName("Windows 10");
   browserOptions.setBrowserVersion("124");
   final HashMap<String, Object> ltOptions = new HashMap<String, Object>();
   ltOptions.put("project", "Selenium ECommerce playground website");
   ltOptions.put("build", "LambdaTest Ecommerce Website tests");
   ltOptions.put("name", "Test broken links on LambdaTest ECommerce playground website");
   ltOptions.put("w3c", true);
   ltOptions.put("visual", true);
   ltOptions.put("w3c", true);
   ltOptions.put("plugin", "java-testNG");

   browserOptions.setCapability("LT:Options", ltOptions);

   return browserOptions;
}

@BeforeTest
public void setup() {
   final String userName = System.getenv("LT_USERNAME") == null ? "LT_USERNAME" : System.getenv("LT_USERNAME");
   final String accessKey = System.getenv("LT_ACCESS_KEY") == null ? "LT_ACCESS_KEY" : System.getenv("LT_ACCESS_KEY");
   final String gridUrl = "@hub.lambdatest.com/wd/hub";

   try {
       this.driver = new RemoteWebDriver(new URL("http://" + userName + ":" + accessKey + gridUrl), getChromeOptions());

   } catch (final MalformedURLException e) {
       System.out.println("Could not start the remote session on LambdaTest cloud grid");
   }

   this.driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(20));
}

@AfterTest
public void tearDown() {
   this.driver.executeScript("lambda-status=" + this.status);
   this.driver.quit();
}

@Test
public void testBrokenLinks() {

   driver.get("https://ecommerce-playground.lambdatest.io/");
   WebElement shopByCategoryMenu = driver.findElement(By.cssSelector("div.shop-by-category a"));
   shopByCategoryMenu.click();
   List<WebElement> shoppingLinks = driver.findElements(By.cssSelector("#widget-navbar-217841 ul li a"));

   for (int i = 0; i <= shoppingLinks.size(); i++) {

       try {
           HttpURLConnection connection = (HttpURLConnection) new URL(shoppingLinks.get(i).getAttribute("href")).openConnection();
           connection.connect();

           URL url = connection.getURL();
           System.out.println(url.toString());

           int responseCode = connection.getResponseCode();
           System.out.println("Response Code for :" +shoppingLinks.get(i).getText() + " is: " + responseCode);
           connection.disconnect();

       } catch (IOException e) {
           throw new RuntimeException(e);
       }
   }
   this.status = "passed";
}

How Do AI Agents Speed Up Selenium WebDriver Debugging?

AI-driven test agents now read a failed Selenium WebDriver run's stack trace and DOM state, then suggest the likely faulty line before a tester sets a single breakpoint.

• Root-cause suggestion: a GenAI testing agent parses a failed run's stack trace, screenshot, and DOM snapshot together, then points to the likely faulty line before a tester opens the debugger.
• Self-healing locators: an AI agent re-resolves a stale element locator after a DOM change, so debugging starts on the real failure instead of a no-such-element false alarm.
• Natural-language breakpoint requests: a tester can ask an agent to pause when a specific action fails, instead of hand-placing a breakpoint on the right line.
• Automated log triage: AI log analysis groups repeated Log4j2 stack traces from a large run into a handful of distinct failure patterns instead of a tester reading each one.

These agents cut the time to locate a failure, but understanding why the code behaves that way still needs a tester stepping through the breakpoint by hand.

Best Practices for Debugging in Test Automation

Wrapping Up!