XPath plays a vital role in locating web elements during automation testing. It is one of the most flexible ways to identify elements in Selenium. Among its many features, XPath axes stand out as a powerful tool. They allow testers to navigate through the structure of a webpage with accuracy and control. This article will explain the top 10 XPath Axes in Selenium that every tester should understand.
What Are XPath Axes in Selenium?
XPath axes define the path between elements in an XML or HTML document. They describe relationships between nodes. In simple words, axes help you move from one element to another in a web page’s DOM. This movement can go forward, backward, or even sideways. Using XPath Axes in Selenium allows testers to locate complex elements that are otherwise hard to identify.
1. ancestor
The ancestor axis locates all parent elements of the current node. It includes the parent, grandparent, and higher-level elements up to the root.
Example:
//div[@id='child']//ancestor::section
This XPath selects all ancestors <section> elements of the <div> element with id='child'.
When to use:
Use it when you need to locate a parent or higher element related to a known child.
2. ancestor-or-self
The ancestor-or-self axis selects the current element and all its ancestors.
Example:
//div[@id='child']//ancestor-or-self::div
This selects the current <div> and its ancestor <div> elements.
When to use:
Use this when you want to include the current node along with its parent hierarchy.
3. child
The child axis is one of the most common. It selects all immediate child elements of the current node.
Example:
//div[@id='container']/child::p
This XPath finds all <p> tags that are direct children of the <div> element.
When to use:
Use it when you only need to target direct children, not nested elements.
4. descendant
The descendant axis finds all elements that are children, grandchildren, or deeper descendants of the node.
Example:
//div[@id='container']//descendant::a
This selects all <a> elements under the <div> element, regardless of depth.
When to use:
Use it when you want to locate all nested elements of a particular type within a container.
5. descendant-or-self
The descendant-or-self axis selects both the current node and all its descendants.
Example:
//div[@id='container']//descendant-or-self::div
This includes the <div> itself and all its descendants <div> elements.
When to use:
Use this when you want to include the current node in addition to its descendants.
6. following
The following axis selects all nodes that appear after the current node in the document.
Example:
//h2[@id='title']//following::p
This selects all <p> elements that come after the <h2> element.
When to use:
Use it to locate elements that appear later in the page structure after a known element.
7. following-sibling
The following-sibling axis selects all sibling elements that appear after the current node.
Example:
//h2[@id='title']//following-sibling::div
This finds all <div> elements that are siblings following the <h2> element.
When to use:
Use it when elements are on the same level in the hierarchy.
8. preceding
The preceding axis selects all nodes that appear before the current node in the document.
Example:
//div[@id='footer']//preceding::h2
This selects all <h2> elements that appear before the <div> element with id='footer'.
When to use:
Use it to identify elements that occur earlier in the HTML structure.
9. preceding-sibling
The preceding-sibling axis finds all sibling elements that come before the current node.
Example:
//p[@id='note']//preceding-sibling::h3
This selects all <h3> elements that come before the <p> elements as siblings.
When to use:
Use it when the target element shares the same parent but appears earlier.
10. self
The self axis represents the current node itself.
Example:
//div[@class='main']//self::div
This simply selects the <div> node itself.
When to use:
Use it when you need to confirm or manipulate the current node directly.
Why XPath Axes in Selenium Matter
XPath axes allow testers to locate elements more precisely. They help navigate complex HTML structures where IDs or classes are not enough. With the right use of XPath Axes in Selenium, testers can handle dynamic or deeply nested elements efficiently. These axes also make test scripts more reliable by reducing dependency on unstable locators.
Best Practices for Using XPath Axes
Here are a few tips to use XPath axes effectively:
- Always start with a unique parent or identifiable element.
- Avoid using overly complex XPath expressions.
- Use text or attribute-based conditions to make your path accurate.
- Combine axes wisely to reach hidden or deeply nested elements.
- Validate your XPath in browser tools before using it in code.
Common Mistakes to Avoid
- Overusing descendant axes — they may slow down the test.
- Ignoring element uniqueness can lead to wrong matches.
- Not checking dynamic attributes — might cause test failures after UI changes.
Conclusion
XPath axes are one of the most powerful parts of Selenium automation. They give testers the flexibility to move through a web page’s structure in many directions. Knowing how and when to use these axes can make automation scripts more stable and efficient. If you master XPath Axes in Selenium, you will easily handle even the most complex web elements.
FAQs
1. What is the use of XPath axes in Selenium?
XPath axes help testers find elements based on their relationship to other elements in the DOM.
2. How many types of XPath axes are there?
There are 13 major XPath axes, but the top 10 are most commonly used.
3. Can I combine multiple XPath axes in one expression?
Yes, you can combine axes to create more specific and accurate XPath expressions.
4. Which XPath axis is used to find elements before a node?
The preceding and preceding-sibling axes help locate elements that appear before the current node.
5. Why are XPath axes important for dynamic web pages?
They allow testers to navigate complex and changing HTML structures effectively, improving test accuracy.
Software Testing Lead providing quality content related to software testing, security testing, agile testing, quality assurance, and beta testing. You can publish your good content on STL.
