RanoreXPath Examples

On this page, you’ll find practical, copy/paste-ready RanoreXPath examples you can use as patterns in your own projects: generalizing paths, switching attributes, using wildcards, narrowing down too many matches, selecting by position, navigating tree views with axes, and identifying related cells in tables

Screencast: The Syntax examples screencast walks you through the information found in this article.

All examples on this page are based on the Ranorex Studio Demo Application. Most of them use the UI-element test area tab.

Reference: Keep the RanoreXPath Quick Reference handy for operators, regex ~, and sibling/ancestor axes.

Download Ranorex Studio Demo Application

Follow the link below to download the file. Then unzip it and start the application.

Identify a simple button and generalize its RanoreXPath

Identify the Exit button by following the example below:

1. In Ranorex Spy, track the Exit button in the demo app’s UI-element test area.
2. Review the generated RanoreXPath and confirm Spy finds 1 element.

Example (generated):

/form[@controlname='RxMainFrame']/button[@controlname='RxButtonExit']

Ranorex Spy shows the following:

1. The automatically generated RanoreXPath for the Exit button.
2. The tree browser shows that the Exit button is a child of the root UI element RxMainFrame.
3. The Exit button is identified by the attribute-value pair @controlname='RxButtonExit'.
4. The Spy status bar (bottom left corner) confirms one UI element found.

Generalize the RanoreXPath

The current example shows how to generalize the RanoreXPath so that the Exit button is only identified by its button role. We do this by removing the button’s attribute. Since the Exit button is the only button at this level in the element tree, it will still be identified correctly and its RanoreXPath is more robust against UI changes.

Generalizing means making the path less detailed (often more robust) by removing attributes—as long as you still get a unique match.

1. In Spy, delete the predicate [@controlname='RxButtonExit'] and press Enter.

2. Confirm Spy still finds the intended element (ideally 1 element).

Example 

/form[@controlname='RxMainFrame']/button

Spy shows the following:

1. The generalized RanoreXPath with only the button role.
2. The tree browser shows the Exit button as a child of the root element.
3. The path editor view represents the generalized RanoreXPath specification.
4. One UI element (for example, the Exit button) has been found.

Note: If there is more than one button (or whichever type of UI element you generalized the RanoreXPath for) is present at the same level in the element tree, the RanoreXPath expression will identify all of them.

When tracking a UI element, Ranorex Studio automatically generates the RanoreXPath and therefore also determines identification attributes automatically. You can of course change the attribute by which a UI element is identified in a RanoreXPath.

1. Track the Exit button in the UI-element test area in the demo app.
2. Click into the RanoreXPath line, then switch to the Path Editor.
3. Select the node whose attribute you want to change, for example, the button in this example.
4. On the left panel, check/uncheck the desired attributes, for example, deselect controlname and select controltext instead for this example. The RanoreXPath is adjusted automatically.

Example

/form[@controlname='RxMainFrame']/button[@controltext='E&xit']

1. The automatically determined controlname attribute was deselected and replaced with the controltext attribute.
2. The RanoreXPath reflects this change.
3. The Path Editor view also reflects this change.
4. The message in the status bar indicates that one element was found for this RanoreXPath.

Wildcards can make a RanoreXPath more resistant to changes in the structure of the UI.

Wildcard quick table

Wildcard	Meaning	Typical use
/*	Any UI element, exactly 1 level	“Skip exactly one node”
/?	Any UI element, 0 or 1 level	“This node may exist or not”
//	Any UI element, any number of levels	“Depth unknown / skip arbitrary nodes”

Tip: Use wildcards sparingly. Too-broad wildcards can increase match counts and reduce precision.

/? (any optional)

Track the UI-element test area tab. Spy may replace intermediate nodes with optional wildcards for robustness.

Example

/form[@controlname='RxMainFrame']/?/?/tabpage[@controlname='RxTabUIElements']

Ranorex Spy will show the following:

1. The root element is represented in the first fixed part of the RanoreXPath expression.
2. The middle UI element TabPageList is not represented. Instead, two /? wildcards replace it to make the path more robust. This is the wildcard part of the RanoreXPath.
3. The final node is the target UI element, for example, the entire UI-element test area tab page. It is the second fixed part of the RanoreXPath.

Interpret the RanoreXPath

/form[@controlname='RxMainFrame']/?/?/tabpage[@controlname='RxTabUIElements']

The  3  target element is a descendant of the 1  root element with a total of either  2  zero, one, or two UI elements between them on two different tree levels.

// (any descendants)

It may often be necessary to identify elements whose “depth” in the UI we don’t know. Any descendant wildcard allows you to circumvent all the intermediate nodes between the root note and the final node.

Example

Enter the following RanoreXPath expression in the tree browser in Ranorex Spy.

/form[@controlname='RxMainFrame']//radiobutton

1.  
   1. The first part of the RanoreXPath expression represents the root node, for example, the demo app window. This is the first fixed node.
   2. The second part is the any descendants wildcard. It is the wildcard node.
   3. The third part is the final node that represents the target UI element. In this case, this is any UI element with the role radiobutton. The expression identifies all radio buttons that are descendants of the root element.
      Spy shows the following results for this RanoreXPath:
      
   4. The RanoreXPath is represented in the path editor.
   5. The tree browser displays seven radio buttons on two different levels (level 3 and level 4).
   6. The status message confirms 7 elements found.

/* (any)

If you know at what “depth” in the UI an element is you want to identify and the intermediate nodes are irrelevant, then the any wildcard is a good choice for making your RanoreXPath more robust.

Example

/form[@controlname='RxMainFrame']/*/*/*/radiobutton

1. The first part of the RanoreXPath expression represents the root node, for example, the demo app window. This is the first fixed node.
2. The second part consists of three wildcards, representing any three UI elements on three different levels. This is the wildcard part of the expression.
3. The third part is the final node that represents the target UI element. In this case, this is any UI element with the role radiobutton. The expression identifies all radio buttons that are exactly three levels below the root element.
   Spy shows the following results for this RanoreXPath:
   
4. The RanoreXPath is represented in the path editor. Each of the wildcard operators represents one level below the root element.
5. The tree browser shows five radiobutton elements exactly three levels below the root element. Any radio buttons at other levels are not identified.
6. The status message confirms five found UI elements.

RanoreXPath expressions can often be too general, resulting in too many or incorrect UI elements being identified. In these cases, you need to make the expression more detailed.

General RanoreXPath

For our example, let’s first create a very general RanoreXPath. We’ll simply identify all buttons in the UI-element test area tab of the Ranorex Studio Demo Application.

Enter a broad path to identify all buttons under the UI-element test area.

Example

/form[@controlname='RxMainFrame']/?/?/tabpage[@controlname='RxTabUIElements']//button

In Spy, enter the following RanoreXPath and press Enter.

1. The RanoreXPath is represented in the path editor.
2. The tree browser shows 17 identified buttons.
3. The status message confirms 17 found UI elements.

Introduce more details

Seventeen buttons are too many. We need to make the RanoreXPath more detailed. We do so by adding an attribute to the button. In this case, we use the visible attribute to identify only buttons that are not hidden.

Example

Change the last part of the RanoreXPath as follows and press Enter.

/form[@controlname='RxMainFrame']/?/?/tabpage[@controlname='RxTabUIElements']//button[@visible='True'] 

1. The new RanoreXPath is represented in the path editor.
2. The tree browser shows 15 buttons.
3. The status message confirms 15 UI elements found.

Even more details

It only reduced the number of buttons by two, so it is necessary to narrow down the RanoreXPath further.  To do so, we can add another attribute and combine it with the previous one using the and operator.

Example

Change the last part of the RanoreXPath as follows and press Enter.

/form[@controlname='RxMainFrame']/?/?/tabpage[@controlname='RxTabUIElements']//button[@visible='True' and @controlname>'btn']

 

1. The RanoreXPath as represented in the path editor, now showing two attributes.
2. The tree browser now shows two UI elements.
3. The status message confirms two UI elements found.

Hint: The and operator is one of several operators available in RanoreXPath syntax.

Results

The more detailed RanoreXPath expression now only identifies the two buttons shown below.

When a RanoreXPath identifies more than one element, you can select from among them by specifying their position in the element tree.

Example

In Ranorex Spy, enter the following RanoreXPath and press Enter.

/form[@controlname='RxMainFrame']/?/?/tabpage[@controlname='RxTabUIElements']//button[@visible='True' and @controlname>'btn'][2]

1. The RanoreXPath as represented in the path editor. The position operator [2] added after the predicate selects the second element from two elements identified by the preceding RanoreXPath.
2. The tree browser only shows the second UI element.
3. The status message confirms one found element.

In the UI of the demo app, this identifies the button Button 1.

Note: Only the position in the element tree is relevant. In the UI itself, the position of the element may be different, as above with Button 1.

Tree views are a common UI element. Here we’ll explain how Ranorex Studio identifies UI elements in them.

1. Click Track in Spy.

2. In the demo app, click the Web and mobile testing tree item.
   

Example

/tree[@controlname='treTestTreeView']/?/?/treeitem[@accessiblename='Web and mobile testing']

Ranorex Spy shows the following:

1. The RanoreXPath for the tree item.
2. Ranorex Studio automatically inserted two ‘any optional’ wildcards (/?/?) to increase robustness.
3. The element tree in Spy shows the tree item Web and mobile testing as a descendant of the tree view.

Subitems in tree views

1. In Ranorex Spy, click the Track button.
2. In the UI-element test area in the demo app, click the Endpoints tree item that is a child of the Web and mobile testing item.

Example for Endpoints

/tree[@controlname='treTestTreeView']//treeitem[@accessiblename='Endpoints']

Ranorex Spy shows the following:

1. The RanoreXPath for the tree item. Note that the subtree item is identified in the same way as its parent, i.e. by its role and an attribute.
2. The ancestor tree view in its entirety serves as a fixed node.
3. Any tree items between the fixed node and the final node are bypassed by any descendants // operator.
4. The subtree item Endpoints is identified regardless of how many ancestor tree items it has.

Note: Ranorex Studio treats all subtree items as regular tree items and identifies them with a predicate (attribute + value) in the same way. To ensure the tree structure does not interfere, it also inserts any descendant operators. This way, it can find the tree item wherever in the tree.

Identify tree siblings with axes

When you want to identify the sibling(s) of a tree item, you can do so by using axes. Axes allow you to specify nodes relative to a specific node. We’ll illustrate this by using the following-sibling axis.

Example

In Ranorex Spy, enter the following RanoreXPath and press Enter.

/treeitem[@accessiblename='Endpoints']/following-sibling::treeitem

1. The RanoreXPath with the added axis following-sibling::treeitem after the part that identifies the Endpoints tree item. This axis means identifies all UI elements that have the role treeitem and are below the Endpoints tree item on the same level in Spy’s element tree.
2. The RanoreXPath as represented in the path editor.
3. The tree browser in Spy displays the tree item Mobile testing, which is the only sibling of the Endpoint item.
   
4. The identification process is illustrated in the UI of the demo app. The RanoreXPath first identifies the Endpoints item and then progresses to the Mobile testing item, which is the following sibling.

Note: following-sibling returns all following siblings if more than one exists.

Here it explains how to identify items in tables works with RanoreXPath.

Test definition

This example shows how to robustly identify the cell that contains the age of the person named Thomas Bach in the table of the UI-element test area in the demo app. This means that you need to identify both the cell that contains the name Thomas and, proceeding from it, the cell that contains the corresponding age.

1. The row with the details for Thomas Bach.
2. The cell that contains the age of Thomas Bach. We want to create a RanoreXPath that identifies it robustly.

Identify the name cell with an absolute RanoreXPath

First, we’ll identify the cell that contains the name Thomas. A simple way is to just track the cell and generate an absolute RanoreXPath to it as in the image below.

1. Absolute RanoreXPath for the marked cell.
2. The RanoreXPath identifies the cell with predicate @accessiblename='FirstName Row3', which reflects the cell’s position in the table. This is the cell that currently has the value Thomas.
3. The identified UI element in the element tree in Spy.

Not robust against changes

The absolute RanoreXPath has its limitations here. When the table changes, the name in the identified cell may not be Thomas anymore, e.g. when you sort the table differently or shuffle it.

1. Shuffling the table cell arrangement shows that…
2. …the absolute RanoreXPath leads to wrong results, as it only cares about the cell position, not the name Thomas.

Specify cell content in the RanoreXPath

Instead of identifying the cell by its accessiblename (which is based on its position), we can use the attribute text. This attribute refers to the text in a cell.

This is still not a robust solution, however, as there are two cells with the text Thomas.

1. The narrowed cell with two attributes forms the RanoreXPath predicate.
2. Only one cell is identified – the Thomas cell in the column FirstName.

Hint: Depending on the case, you may need to make the RanoreXPath even more detailed, e.g., by adding more attributes or with axes.

Going from absolute to relative

Now that it was robustly identified, the cell contains the first name, Thomas. Look at identifying the corresponding cell that holds Thomas’s age.

Now, you have to make the path relative. This means that the parent axis (abbreviated: ..) is used to navigate from an anchor point (the Thomas cell) back to the row and from there to the age cell in that row. This ensures the age cell is tied to the position of the Thomas cell and, therefore, always identified correctly.

1. The relative RanoreXPath with the parent axis and the age cell being identified by its accessiblename.
2. This identifies the cell with the age of Thomas Bach (42) correctly.