The Future of UI Element Targeting: Why FinalRun Beats XPath

Overview

Robust, maintainable UI automation begins with precise element identification. This documentation introduces FinalRun’s JSON-based identifier framework and explores its advantages compared to traditional XPath-based selectors commonly used with Appium. Emphasizing relational identifiers, it guides automation engineers to build resilient, clear, and scalable tests for dynamic interfaces.

1. Introduction to Element Identification

In automated testing, the method used to find elements determines the reliability and maintainability of test suites. Two dominant approaches are:

• XPath Selectors (Appium): String-based queries that traverse the UI hierarchy.

• FinalRun Identifiers: Declarative, JSON-based objects combining attributes and relationships.

2. XPath with Appium: Structure-Based Selection

XPath is a query language for targeting nodes in an XML document, mapped to UI element structures in Appium.

Strengths

• Universal; works across many platforms.

• Can express complex UI hierarchies.

Limitations

• Fragile: Breaks with minor UI changes.

• Difficult Maintenance: Often requires updates after UI refactoring.

• Cryptic Syntax: Not intuitive; error-prone string manipulation.

• Performance: Deep or complex queries can slow tests.

3. FinalRun Identifiers: Attribute and Relationship-Based Targeting

FinalRun introduces a modern, JSON-driven approach, focusing on both the properties and relationships of UI elements.

Properties

• id: Unique resource name.

• text: Displayed text.

• type: Element type (e.g., image).

• accText: Accessibility label.

Relationships (Relational Identifiers) — The Game Changer

• insideOf: Specifies a parent container.

• containsDescendants: Element must have specified children.

• rightOf, leftOf, topOf, bottomOf: Spatial positioning. Not possible with Xpath

• index: 1-based (selects the nth match within context).

Example Identifier:

{
  "text": "Submit",
  "insideOf": { "id": "footer" }
}

• Clearly identifies the element with Submit text inside the footer container. Works regardless of UI changes as long as the Submit text is inside the footer container.

Checkout the detailed documentation — https://finalrun.gitbook.io/finalrun/advanced/element-identifier

What Makes Relational Identifiers Special?

• Contextual Targeting: Define elements by their relation to others, not just absolute position in the hierarchy.

• Resiliency: Less impacted by UI layout changes.

• Clarity: Self-documenting JSON; easily readable/reusable across teams.

• Disambiguation: Combine relationships to uniquely identify elements in complex views.

📅 Book a Demo
See how FinalRun fits into your existing workflow with a live Demo.

5. Practical Scenarios

Scenario 1: Spatial Relationship (Icon Right of “Settings” Text)

UI layout often positions elements side-by-side. For example, an icon may appear visually to the right of a “Settings” label. This spatial relationship is critical but not captured by hierarchy alone.

XPath: (Not possible)

//android.widget.TextView[@text='Settings']/following-sibling::android.widget.ImageView

Limitation with Xpath: This only selects the image that comes after “Settings” in the view hierarchy — not necessarily to its right on screen.

FinalRun:

{
  "type": "icon",
  "rightOf": { "text": "Settings" }
}

FinalRun uses actual screen coordinates to resolve spatial relationships, ensuring the icon is genuinely to the right of the “Settings” label — regardless of their order in the XML layout. XPath cannot guarantee this and often fails when layout shifts or rendering engines change order independently of the DOM.

Scenario 2: Parent Element Containing Specific Children

Let’s say you want to identify a section that contains both a “Title” text and a “Continue” button.

XPath:

//android.view.ViewGroup[.//android.widget.TextView[@text='Title'] and .//android.widget.Button[@text='Continue']]

FinalRun:

{
  "containsDescendants": [
    { "text": "Title" },
    { "text": "Continue" }
  ]
}

FinalRun expresses the same logic in a much clearer, structured form — greatly improving readability and making the intent explicit. XPath handles this by nesting logical conditions in a dense string expression that is harder to maintain.

6. Best Practices with FinalRun Identifiers

• Prioritize unique attributes (id, text, accText, type).

• Add relational context (insideOf,leftOf, topOf, bottomOf rightOf) to eliminate ambiguity.

• Use indexing judiciously — only when necessary

7. Conclusion

FinalRun’s relational, spatial and property-driven identifiers significantly advance UI automation capabilities beyond XPath’s positional approach. By blending clear structure, human readability, and robust context-awareness, FinalRun maximizes both test reliability and developer productivity for today’s fast-moving interfaces.

Embrace relational identifiers to unlock a modern, resilient, and scalable automation strategy.

Related Reading

Read our story behind why we took this new approach to element identification:

How We Set Out to Solve the XPath Problem in Mobile UI Test Automation

📅 Book a Demo
See how FinalRun fits into your existing workflow with a live Demo.