On this page, you’ll find out how RanoreXPaths are structured and how RanoreXPath characteristics relate to automated software testing. First, let's explain the RanoreXPath structure for an isolated UI element, and then for this UI element as part of the UI it is situated in. Finally, it is important to explain what robustness and flexibility are about RanoreXPaths and how to make use of them for test automation purposes.

Screencast: The screencast RanoreXPath blueprint walks you through the information found in this chapter

A full RanoreXPath usually identifies an element in context (within its UI hierarchy). To understand the basics, it helps to look at the structure needed to identify a single UI element in isolation—such as the Exit button in the Ranorex Studio Demo Application.

1. Basic structure: The RanoreXPath for an isolated UI element consists of three elements: an axis specifier, a node, and zero or more predicate(s) (all explained below).
2. For the isolated Exit button, the axis specifier is /, the node is the role button, and the predicate consists of an attribute-value pair that uniquely identifies the button.

Axis

• Ranorex Studio treats the UI as a hierarchical tree.
• Axis specifiers define how the RanoreXPath navigates in that tree.
• Examples: /, //, .., ancestor Review more information in RanoreXPath syntax.

Node/role

• A node represents a UI element in the element tree.
• In RanoreXPath, the UI element’s role is the primary property by which it is identified.
• For more detailed identification, roles can be further specified with predicates enclosed in square brackets [].

Predicate/attribute-value pair

• Predicates further specify a node/role. They are optional.
• A predicate normally consists of one or more attribute-value pairs.
• Predicates are enclosed in square brackets.
• Attribute-value syntax is: @attribute='value' , where = is the operator.
• Operators other than = are available for use (explained here).
• Predicates may also contain regular expressions.

Above we explained the basic structure of the RanoreXPath for an isolated button, for example, one isolated node in the UI element tree.

Ignored the ancestor nodes that represent the UI this button is embedded in (for example, the Ranorex Studio Demo Application window, the Introduction tab, etc.). Naturally, to identify the button in a real-life scenario, the RanoreXPath needs to navigate through all these ancestor nodes to get to the Exit button.

Chain isolated RanoreXPaths together

In real tests, RanoreXPath must navigate through the UI hierarchy that contains the target element. To reach the Exit button, you chain the RanoreXPaths of the nodes leading to it into one full RanoreXPath.

This RanoreXPath consists of three parts that can be considered the basic parts of all RanoreXPaths:

1. Root element: The root of the current UI element tree. This is the starting point for navigating to the final node/UI element.
2. Path from root to final node: The nodes are between the root and the final node. Can be zero or more.
3. Final node/UI element: The UI element you want to identify.

Note: All RanoreXPaths have these three parts, but these three parts don’t have to be expressed in three nodes. They can also be expressed in just one node (for example, when identifying only the Ranorex Studio Demo Application window), in two nodes (no other nodes between root and final node), or many more than three (several nodes between root and final node).

Example: Exit button (tracked in Spy)

Let’s take a look at the full RanoreXPath for the Exit button, as it’s generated when tracking the button from Ranorex Spy.

1. Tracked Exit button.
2. The RanoreXPath was generated for the button by Ranorex Spy.
   The views in Spy provide more details and demonstrate which UI elements the RanoreXPath navigates through/identifies.
3. The UI element tree browser shows the two UI elements in the RanoreXPath in the UI hierarchy.
   The root element is the program window (role form) of the demo app.
   It is identified by the attribute-value pair controlname='RxMainFrame'.
   The final node is the Exit button.
   It is identified by attribute-value pair controlname='RxButtonExit'.
   There are no intermediate nodes between the root and the final node.
4. The path editor shows a more visual representation of the RanoreXPath, with details as to what node corresponds to what part of the RanoreXPath expression.

In UI test automation, robustness means that the test still works if changes are made to the UI, e.g. moving a button from one place to another or changing its label. In Ranorex Studio, this is accomplished through the RanoreXPath.

An ideal RanoreXPath is as detailed as necessary (= faster UI-element identification and therefore execution speed) and as flexible (= more reliable UI-element identification, i.e. a more robust test) as possible.

• The level of detail vs. flexibility impacts robustness and execution speed.
• A very detailed RanoreXPath leads to less robust declarations but may speed up test execution.
• A very flexible RanoreXPath is more robust against UI changes, but may also slow down test execution.

Reference: Ranorex Studio generates RanoreXPaths based on a sophisticated algorithm that automatically balances robustness and flexibility. The behavior of this algorithm can be modified in Ranorex Studio under Settings > Advanced > RanoreXPath settings. This is explained in more detail Advanced settings and configurations.