Window handles (getWindowHandles) in Selenium Java - Build an Automation Script

Verify switching between multiple browser windows using getWindowHandles

Preconditions (2)

Step 1: Open the main test page URL

Step 2: Click on the link that opens a new browser window

Step 3: Get all window handles using getWindowHandles()

Step 4: Switch to the newly opened window

Step 5: Verify the title of the new window is as expected

Step 6: Close the new window

Step 7: Switch back to the original window

Step 8: Verify the title of the original window is as expected

✅ Expected Result: The test switches correctly between the original and new window, verifies titles, and closes the new window without errors.

Automation Requirements - Selenium WebDriver with Java

Assertions Needed:

Verify the new window title matches expected

Verify the original window title matches expected after switching back

Best Practices:

Use explicit waits if needed before switching windows

Store original window handle before opening new window

Use getWindowHandles() to get all open windows

Switch windows using driver.switchTo().window(handle)

Close only the new window, not the original

Use try-finally or proper cleanup to avoid leftover windows

Automated Solution

Selenium Java

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
import java.time.Duration;
import java.util.Set;

public class WindowHandlesTest {
    public static void main(String[] args) {
        System.setProperty("webdriver.chrome.driver", "path/to/chromedriver");
        WebDriver driver = new ChromeDriver();
        WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));

        try {
            // Step 1: Open main page
            driver.get("https://example.com/testpage");
            String originalWindow = driver.getWindowHandle();

            // Step 2: Click link that opens new window
            driver.findElement(By.id("open-new-window")).click();

            // Step 3: Wait for new window
            wait.until(driver1 -> driver1.getWindowHandles().size() > 1);

            // Step 4: Get all window handles
            Set<String> allWindows = driver.getWindowHandles();

            // Step 5: Switch to new window
            for (String windowHandle : allWindows) {
                if (!windowHandle.equals(originalWindow)) {
                    driver.switchTo().window(windowHandle);
                    break;
                }
            }

            // Step 6: Verify new window title
            String newWindowTitle = driver.getTitle();
            if (!newWindowTitle.equals("New Window Title")) {
                throw new AssertionError("New window title mismatch. Expected: 'New Window Title', Found: '" + newWindowTitle + "'");
            }

            // Step 7: Close new window
            driver.close();

            // Step 8: Switch back to original window
            driver.switchTo().window(originalWindow);

            // Step 9: Verify original window title
            String originalTitle = driver.getTitle();
            if (!originalTitle.equals("Original Window Title")) {
                throw new AssertionError("Original window title mismatch. Expected: 'Original Window Title', Found: '" + originalTitle + "'");
            }

            System.out.println("Test passed: Window handles switched and verified successfully.");

        } finally {
            driver.quit();
        }
    }
}

This code starts by opening the main test page and saving the original window handle. It clicks a link that opens a new window. Then it waits until there are more than one window handles available.

It collects all window handles and switches to the one that is not the original. It verifies the new window's title matches the expected value.

After verification, it closes the new window and switches back to the original window. It then verifies the original window's title to confirm the switch back was successful.

Finally, it quits the driver to close all browser windows. The code uses explicit waits and proper window handle management to avoid errors.

Common Mistakes - 4 Pitfalls

Not storing the original window handle before opening the new window

Using Thread.sleep() instead of explicit waits to wait for new window

Closing the original window instead of the new window

Hardcoding window handles or assuming order of handles

Bonus Challenge

Now add data-driven testing with 3 different links that open different new windows and verify their titles.

Show Hint

Practice

1. What does the Selenium method getWindowHandles() return when called?

easy

A. A set of all open window handles (IDs) in the current WebDriver session

B. The handle of the current active window only

C. The title of the current browser window

D. The URL of the current page

Solution

1. Step 1: Understand the purpose of getWindowHandles()

   This method is designed to return all window handles for every open window or tab in the current browser session.

2. Step 2: Identify the return type

   The method returns a Set of Strings, each representing a unique window handle (ID).

3. Final Answer:

   A set of all open window handles (IDs) in the current WebDriver session -> Option A

4. Quick Check:

   getWindowHandles() = all window IDs [OK]

Hint: Remember: getWindowHandles() returns all window IDs as a set [OK]

Common Mistakes:

• Confusing getWindowHandles() with getWindowHandle() which returns one handle
• Expecting a list or array instead of a set
• Thinking it returns page titles or URLs

2. Which of the following is the correct syntax to get all window handles in Selenium Java?

easy

A. List<String> handles = driver.getWindowHandles();

B. String handles = driver.getWindowHandles();

C. Set<String> handles = driver.getWindowHandles();

D. Set handles = driver.getWindowHandle();

Solution

1. Step 1: Check the return type of getWindowHandles()

   The method returns a Set of Strings, so the variable must be declared as Set<String>.

2. Step 2: Verify method name and syntax

   The correct method is getWindowHandles() (plural), and it belongs to the WebDriver instance named driver.

3. Final Answer:

   Set<String> handles = driver.getWindowHandles(); -> Option C

4. Quick Check:

   Correct syntax uses Set<String> and getWindowHandles() [OK]

Hint: Use Set<String> for getWindowHandles() return type [OK]

Common Mistakes:

• Using List instead of Set for window handles
• Calling getWindowHandle() instead of getWindowHandles()
• Assigning to a String instead of a collection

3. Consider the following code snippet:

Set<String> handles = driver.getWindowHandles();
System.out.println(handles.size());

If the browser has 3 tabs open, what will be printed?

medium

A. An exception is thrown

B. 1

C. 0

D. 3

Solution

1. Step 1: Understand what getWindowHandles() returns

   It returns a set containing all window handles for every open tab or window.

2. Step 2: Determine the size of the set

   Since there are 3 tabs open, the set will contain 3 unique handles, so size() returns 3.

3. Final Answer:

   3 -> Option D

4. Quick Check:

   Number of tabs = size of handles set = 3 [OK]

Hint: Size of getWindowHandles() set equals number of open tabs/windows [OK]

Common Mistakes:

• Assuming size() returns 1 for current window only
• Expecting an exception if multiple tabs exist
• Confusing getWindowHandles() with getWindowHandle()

4. You wrote this code to switch to a new window:

Set<String> handles = driver.getWindowHandles();
String newWindow = handles.iterator().next();
driver.switchTo().window(newWindow);

But it always switches to the original window. What is the likely problem?

medium

A. getWindowHandles() returns an empty set

B. Using iterator().next() returns the first handle, which is the original window

C. switchTo().window() requires window title, not handle

D. You must convert the set to a list before switching

Solution

1. Step 1: Analyze iterator().next() behavior on a Set

   Calling iterator().next() on a Set returns the first element, which is usually the original window handle.

2. Step 2: Understand why it switches to original window

   Since newWindow is assigned the original window handle, switching to it does not change the window.

3. Final Answer:

   Using iterator().next() returns the first handle, which is the original window -> Option B

4. Quick Check:

   iterator().next() = first handle (original window) [OK]

Hint: iterator().next() returns first handle, often original window [OK]

Common Mistakes:

• Assuming iterator().next() gives the new window handle
• Thinking switchTo().window() needs window title
• Not checking if getWindowHandles() is empty

5. You want to switch to a newly opened window different from the original one. Given String originalHandle = driver.getWindowHandle(); and Set<String> allHandles = driver.getWindowHandles();, which code correctly switches to the new window?

hard

A. for (String handle : allHandles) { if (!handle.equals(originalHandle)) { driver.switchTo().window(handle); break; } }

B. driver.switchTo().window(allHandles.iterator().next());

C. driver.switchTo().window(originalHandle);

D. driver.switchTo().window(allHandles.toArray()[0].toString());

Solution

1. Step 1: Identify the original window handle

   We have the original window handle stored in originalHandle.

2. Step 2: Loop through all handles to find the new one

   Iterate over all handles and switch to the one that is not equal to the original handle.

3. Step 3: Switch to the new window

   Once found, call driver.switchTo().window(handle) and break the loop.

4. Final Answer:

   for (String handle : allHandles) { if (!handle.equals(originalHandle)) { driver.switchTo().window(handle); break; } } -> Option A

5. Quick Check:

   Switch to handle != originalHandle [OK]

Hint: Loop handles, skip original, switch to new [OK]

Common Mistakes:

• Switching to first handle without checking if it's original
• Using toArray()[0] which may be original window
• Switching to originalHandle instead of new window