UFT Mobile Object Identification Guide

Mastering Object Identification in UFT for Mobile Applications: A Comprehensive Guide to Handling Identification Issues

Object identification in Unified Functional Testing (UFT) presents unique challenges when it comes to mobile applications, where dynamic elements and diverse platforms can cause test failures. This comprehensive guide explores the intricacies of object identification in mobile environments and provides practical solutions to overcome common identification issues.

Understanding UFT's Object Identification Mechanism

Object identification in UFT refers to the process by which the tool recognizes and interacts with various elements within mobile applications. This mechanism is essential for creating stable and maintainable automated tests that can accurately simulate user interactions. In mobile testing, UFT uses a combination of properties to uniquely identify objects such as buttons, text fields, images, and other UI elements. These properties include the object's type, name, index, and other attributes specific to the mobile platform being tested.

UFT employs a sophisticated object identification system that uses properties to uniquely identify elements in applications. When testing mobile applications, this process becomes more complex due to the varied nature of mobile devices and operating systems. UFT first attempts to identify objects using a set of default properties configured in the Object Identification settings. When these properties aren't sufficient, UFT can employ additional mechanisms like ordinal identifiers or smart identification to locate objects.

The object identification process in UFT follows a specific workflow:

1. UFT attempts to identify objects using the properties defined in the Object Repository

2. If the primary properties don't yield a unique match, UFT may use ordinal identifiers

3. If both methods fail, Smart Identification can be used as a fallback mechanism

4. If all methods fail, the test will report an object not found error

Mobile applications often have dynamic properties that change with each test run, requiring testers to configure UFT properly to handle these variations. For example, a list item in a mobile app might have a different index each time the application runs, making ordinal identification unreliable. In such cases, testers must identify more stable properties that remain consistent across test runs, such as accessibility labels or unique resource IDs.

Common Object Identification Challenges in Mobile Testing

Mobile applications present several unique challenges for object identification that differ from traditional desktop applications. The dynamic nature of mobile UI elements, frequent updates to application versions, and the wide variety of device sizes and operating systems can all contribute to identification issues. Common challenges include objects with changing properties, overlapping elements, and accessibility identifiers that behave differently across platforms. Additionally, mobile applications often use native controls that have different identification properties than web elements.

Key challenges specific to mobile object identification include:

• Dynamic content that changes between test runs
• Different behaviors on various device types and operating systems
• Complex UI hierarchies in mobile applications
• Touch targets with special properties and behaviors
• Hybrid applications combining native and web elements

Mobile application testing presents several unique challenges for object identification that can frustrate even experienced automation engineers. Dynamic content that changes frequently during runtime is one of the most common issues, as UFT may struggle to locate objects when their properties or hierarchy alters between test runs. The fragmentation across different mobile platforms adds another layer of complexity, as objects in iOS applications may have different identification properties compared to their Android counterparts. Native mobile applications often employ complex UI hierarchies with nested elements that can make object identification particularly challenging.

Testers must also account for touch targets that may be smaller or have different behaviors than traditional GUI elements. Understanding these challenges is the first step toward developing effective solutions for stable mobile test automation. For instance, a button that works perfectly on a large tablet might fail identification on a small smartphone due to different rendering properties. Testers need to develop strategies that work across the range of devices their applications support.

Configuring Object Identification Settings for Mobile Environments

Proper configuration of UFT's Object Identification settings is essential for successful mobile application testing. Start by accessing the Object Identification dialog through Tools > Object Identification. Here, you can configure which properties UFT uses to identify objects from different test object classes. For mobile applications, it's often necessary to modify the properties for native controls and hybrid elements. Consider including properties like accessibility labels, content descriptions, and unique resource IDs that are more stable across different device configurations.

When configuring object identification for mobile applications, follow these best practices:

• Prioritize stable properties like accessibility IDs and content descriptions
• Avoid using properties that might change with application updates
• Configure different settings for native and hybrid elements
• Test your configuration on multiple device types and operating systems
• Document your configuration decisions for future reference

You can also adjust the ordinal identifier settings to use spatial relationships when other properties aren't sufficient. When configuring these settings, it's important to balance uniqueness with stability - properties that are too specific may cause failures when the application changes, while properties that are too general may lead to ambiguous identification. For example, while a button's text might change between application versions, its accessibility label might remain stable, making it a better choice for object identification.

Here's an example of how you might configure object properties for a mobile button in UFT:

' Setting object properties for a mobile button
Set mobileButton = Description.Create()
mobileButton("nativeclass").Value = "UIButton"
mobileButton("accessibilitylabel").Value = "SubmitButton"
mobileButton("contentdescription").Value = "Submit"
mobileButton("index").Value = 0

Implementing Smart Identification Techniques

When standard object identification fails, UFT's Smart Identification feature can provide a backup mechanism. Smart Identification uses a set of additional properties to try to identify an object when the primary identification method fails. For mobile applications, this feature can be particularly useful when dealing with dynamic content or frequently changing UI elements. To implement Smart Identification effectively, configure the Smart Identification properties in the Object Identification dialog.

Select properties that are likely to remain stable even when other properties change. For mobile applications, these might include:

• Accessibility labels
• Content descriptions
• Unique resource IDs
• Parent object properties

It's important to note that Smart Identification should be used judiciously - enabling it for all objects can slow down test execution and may lead to unintended object matches. Consider using Smart Identification only for objects that frequently fail standard identification methods, and always verify that it correctly identifies the intended objects in your test environment. When properly configured, Smart Identification can significantly reduce test failures caused by minor changes in application properties.

Here's an example of implementing Smart Identification in UFT for a mobile element:

' Using Smart Identification when standard properties fail
On Error Resume Next
Set mobileElement = Mobile("Device").MobileWindow("AppWindow").MobileButton("btnSubmit")
If mobileElement.Exist(0) Then
    mobileElement.Click
Else
    ' Fallback to Smart Identification
    Set smartElement = Mobile("Device").MobileWindow("AppWindow").MobileButton("accessibilitylabel:=SubmitButton")
    If smartElement.Exist(0) Then
        smartElement.Click
    Else
        Reporter.ReportEvent micFail, "Button Click", "Could not find the Submit button"
    End If
End If
On Error GoTo 0

Advanced Techniques for Handling Complex Mobile Objects

Some mobile application elements require advanced techniques beyond standard object identification. For these challenging objects, UFT offers several approaches to improve identification reliability. One technique is to use programmatic descriptions in your test scripts, allowing you to specify object properties directly in the code. Another approach is to use the Object Repository utility to modify object descriptions manually when standard identification fails.

You can also employ regular expressions in property values to match objects with varying text or other dynamic properties. For particularly stubborn objects, consider using the UFT's Test Object Model to navigate through the application's object hierarchy and locate elements based on their relationships to other objects. These advanced techniques require a deeper understanding of UFT's object model but can significantly improve the stability of your mobile test automation.

UFT employs several sophisticated mechanisms to identify objects in mobile applications, each designed to address different identification challenges. The default approach uses a set of predefined properties configured in the Object Identification settings to locate objects based on their characteristics. When these properties are insufficient, UFT can leverage ordinal identifiers that consider an object's position relative to other elements in the UI. Smart identification serves as an advanced fallback mechanism that intelligently selects properties that are most likely to uniquely identify an object, even when some properties may change.

Here's an example of using regular expressions in object identification:

' Example of using regular expressions in object identification
Set mobileButton = Description.Create()
mobileButton("text").Value = "Submit.*" ' Matches any button with text starting with "Submit"
mobileButton("class").Value = "UIButton"
Set button = Mobile("Device").mobileButton(mobileButton)
button.Click

When standard object identification methods fall short, testers can employ several advanced techniques to enhance object recognition in mobile applications. Creating custom object repositories allows for tailored identification strategies specific to the application under test, addressing unique challenges that may not be covered by UFT's default settings. Programmatic object identification provides the flexibility to implement custom identification logic using scripting, enabling testers to develop sophisticated algorithms for complex scenarios. Descriptive programming offers another powerful approach by allowing object properties to be specified directly within the test script, eliminating dependencies on stored object repositories.

// Example of descriptive programming in UFT for mobile testing
function clickDynamicElement(elementText) {
    var desc = Mobile().MobileWebView().WebElement();
    desc("innertext").RegExp = ".*" + elementText + ".*";
    Mobile().MobileWebView().WebElement(desc).Click();
}

// Usage in test
clickDynamicElement("Continue");

For particularly challenging scenarios, combining multiple identification techniques or implementing wait mechanisms that account for application loading times can significantly improve test stability.

Best Practices for Maintaining Stable Object Identification

Maintaining stable object identification across different test runs requires following several best practices. First, establish a consistent naming convention for objects in your Object Repository to improve organization and maintainability. Second, prioritize using stable properties that are less likely to change with application updates, such as unique resource IDs or accessibility labels. Third, implement regular maintenance of your Object Repository to update object descriptions when application changes occur.

Additionally, consider using parameterization for properties that may vary across test environments or devices. It's also important to document your object identification strategy and any special handling for problematic objects. Finally, always verify object identification after making changes to your application or UFT configuration, as seemingly minor changes can significantly impact object recognition.

Implementing best practices for object identification can dramatically improve the stability and maintainability of your mobile automation tests. Setting up well-organized object repositories with clear naming conventions makes it easier to locate and update object definitions as the application evolves. Establishing consistent identification strategies across your test suite ensures that tests behave predictably and reduces maintenance overhead. Regularly reviewing and updating object properties is essential as mobile applications frequently change during development cycles.

Consider implementing these practices in your mobile testing workflow:

• Regular reviews of object identification properties
• Version control for Object Repository changes
• Automated checks for object identification stability
• Documentation of special handling for problematic objects
• Cross-platform testing to ensure identification works across devices

• Key considerations for mobile object repositories:
• Organize objects by feature or component
• Use descriptive names that clearly indicate the element's purpose
• Regularly prune unused or obsolete object definitions
• Maintain version control for object repository changes

Troubleshooting Guide: When UFT Fails to Identify Objects

When UFT cannot identify objects in your mobile application, a systematic approach to troubleshooting can help quickly identify and resolve the issue. Begin by examining the object's properties in the UFT Object Spy to determine which properties are being used for identification and whether they're changing between runs. Check for timing issues by adding appropriate wait statements that account for application loading or rendering times. If the application contains dynamic content, consider implementing dynamic identification techniques that can handle changing properties. For complex UI hierarchies, try simplifying the identification by using parent objects or alternative properties that are more stable. Regularly updating UFT and its mobile add-ins can also resolve compatibility issues that may affect object recognition.

• Common solutions for object identification failures:
• Use regular expressions to handle variable text in object properties
• Implement index-based identification when other properties are unreliable
• Create custom object classes with specific identification properties
• Utilize UFT's Smart Identification feature as a fallback mechanism

Conclusion

Mastering object identification in UFT for mobile applications is essential for creating reliable, maintainable automation that can withstand the challenges of diverse mobile environments. By understanding UFT's identification mechanisms, implementing best practices, and knowing how to troubleshoot common issues, testers can significantly improve the effectiveness of their mobile automation efforts. As mobile applications continue to evolve with more complex architectures and dynamic content, the importance of robust object identification strategies will only grow.

Object identification in UFT for mobile applications requires a thoughtful approach that balances technical knowledge with practical problem-solving skills. By understanding UFT's identification mechanisms, configuring settings appropriately, and implementing advanced techniques when needed, testers can create robust automation that withstands application changes and device variations. Investing time to develop a solid approach to object identification will pay dividends in test stability, reduced maintenance overhead, and ultimately, higher quality mobile applications delivered to end users.

Frequently Asked Questions

• What makes object identification challenging in mobile applications?
  Mobile applications present unique challenges including dynamic content that changes between test runs, different behaviors across device types and operating systems, complex UI hierarchies, and special touch target properties that differ from traditional GUI elements.
• How can I configure UFT for better mobile object identification?
  Access Object Identification through Tools > Object Identification and prioritize stable properties like accessibility labels and resource IDs. Configure different settings for native and hybrid elements, and test your configuration across multiple device types to ensure reliability.
• When should I use Smart Identification in UFT mobile testing?
  Smart Identification should be used as a fallback when standard object identification fails, particularly for objects with frequently changing properties. Configure it with stable properties like accessibility labels and content descriptions, but use it judiciously as it can slow down test execution.
• What are advanced techniques for handling complex mobile objects?
  Advanced techniques include using programmatic descriptions in test scripts, implementing regular expressions in property values, leveraging the Test Object Model to navigate object hierarchies, and creating custom object repositories tailored to your application's unique challenges.
• How can I maintain stable object identification across test runs?
  Maintain stability by establishing consistent naming conventions, prioritizing stable properties like unique resource IDs, implementing regular maintenance of your Object Repository, using parameterization for varying properties, and documenting your identification strategy for future reference.