Mastering UFT Object Identification

Object Identification in UFT: Mastering Custom Identification Methods and Override Techniques

In the world of automated testing, Unified Functional Testing (UFT) stands as a powerful tool for ensuring application quality, with object identification serving as its cornerstone for interacting with application elements. Understanding how UFT identifies objects and implementing custom identification methods and override techniques can significantly enhance your test automation framework's reliability and efficiency.

Understanding the Basics of Object Identification in UFT

Object identification in UFT is the fundamental process through which the test automation tool recognizes and interacts with various UI elements within an application. When you record a test, UFT captures properties of objects to create test object descriptions that it uses during playback to locate these objects. This identification mechanism forms the backbone of all automated interactions in UFT, dictating how your tests will find and manipulate elements in your application.

The object identification process involves several key components that work together to ensure accurate recognition of UI elements. Each object in an application has a set of properties that describe its characteristics, such as name, type, location, and other attributes. UFT uses these properties to create a unique "description" of each object.

• Properties like "class", "text", and "index" are commonly used for object identification
• The Object Repository stores these properties for each test object
• During execution, UFT matches the runtime object with the stored description

The effectiveness of your automated tests heavily depends on how well UFT can identify objects. If identification fails, tests may produce false negatives or fail altogether, leading to unreliable test results and maintenance challenges.

Standard Object Identification Process in UFT

The standard object identification process in UFT follows a systematic approach to recognize and interact with application elements. When UFT attempts to identify an object, it first checks the Object Repository to find a matching test object based on the stored description. If a unique match is found, the process completes successfully, and the test can proceed with the specified action on that object.

If no unique match is found, UFT may employ ordinal identifiers as a fallback mechanism. Ordinal identifiers use the object's position relative to other objects, such as its index in a collection or its location coordinates on the screen.

• Index identifier: Uses the object's position within a collection of similar objects
• Location identifier: Uses the x and y coordinates of the object on the screen
• Creation time identifier: Uses the order in which the object was created

These default mechanisms provide a foundation for object identification, but they may not always be sufficient for complex applications. When standard identification methods fail, UFT can activate its Smart Identification feature, which attempts to identify objects using a more flexible approach based on a set of base filter properties and associated properties.

The default identification settings can be configured through the Object Identification dialog in UFT, allowing testers to customize which properties are used for different object types. This customization is essential for handling applications with unique UI characteristics.

Custom Identification Methods in UFT

When standard object identification methods fall short, implementing custom identification techniques becomes essential for creating robust test automation frameworks. Custom identification methods involve defining your own set of properties or algorithms to uniquely identify objects in your application. This approach is particularly valuable when dealing with web applications that use dynamic content, frameworks with auto-generated IDs, or complex UI structures where default properties may not provide sufficient uniqueness.

One approach to custom identification is modifying the Object Identification settings for specific object types. This involves specifying which properties UFT should use when identifying objects of a particular class. For example, you might instruct UFT to use the "attached text" property for identifying buttons in your application, rather than relying solely on the default properties.

' Example of custom identification using programmatic description
Set Button = Description.Create()
Button("micclass").Value = "Button"
Button("text").Value = "Submit"
Button("html tag").Value = "BUTTON"

' Use this custom description to identify the button
Set SubmitButton = Browser("MyApplication").Page("HomePage").ChildObjects(Button)(0)

Another effective custom identification method is the use of regular expressions to match object properties based on patterns rather than exact values. This technique proves especially useful when dealing with objects that have consistent naming conventions but include variable elements like timestamps or sequence numbers.

' Custom identification using regular expressions
Set description = Description.Create()
description("micclass").Value = "WebEdit"
description("name").RegularExpression = "username_[0-9]+"
Set obj = Browser("name:=.*").Page("name:=.*").ChildObjects(description)

Another powerful custom identification technique is using the Descriptive Programming approach. This method allows you to describe objects directly in your test script rather than storing them in the Object Repository. Descriptive Programming provides greater flexibility and can significantly reduce maintenance overhead for applications with dynamic or frequently changing UI elements.

' Example of Descriptive Programming
Browser("MyApplication").Page("HomePage").WebEdit("name:=username").Set "testuser"
Browser("MyApplication").Page("HomePage").WebEdit("name:=password").Set "testpass123"
Browser("MyApplication").Page("HomePage").WebButton("text:=Login").Click

Implementing custom identification methods requires a thorough understanding of your application's object structure and the properties that uniquely identify each element. By tailoring identification techniques to your specific needs, you can create more reliable and maintainable automated tests.

Override Techniques for Enhanced Object Recognition

Override techniques in UFT provide additional flexibility for object identification by allowing testers to modify or supplement the default identification process. These techniques become particularly valuable when dealing with dynamic applications, custom controls, or objects that change frequently between test runs.

One common override technique is the use of programmatic object descriptions within your test scripts. Unlike the Object Repository, which stores static object descriptions, programmatic descriptions allow you to define object properties dynamically at runtime. This approach is especially useful for objects that have varying properties between test executions.

' Example of dynamic object identification
Function GetDynamicObject(objName, objType)
    Set objDesc = Description.Create()
    objDesc("micclass").Value = objType
    objDesc("name").Value = objName
    
    ' Additional properties based on runtime conditions
    If IsDate(Date) Then
        objDesc("text").Value = "Generated on " & Date
    End If
    
    Set GetDynamicObject = objDesc
End Function

' Usage
Set myObject = Browser("MyApp").Page("Home").ChildObjects(GetDynamicObject("dynamicButton", "WebButton"))(0)

Another powerful override technique involves using the SetTOProperty and GetROProperty methods to manipulate object properties during test execution. SetTOProperty allows you to modify the test object's properties stored in the Object Repository, while GetROProperty retrieves the actual runtime properties of an object.

' Override technique using SetTOProperty
Browser("Browser").Page("Page").WebList("list").SetTOProperty "item count", 5
Browser("Browser").Page("Page").WebList("list").Select "New Item"

The Visual Relation Identifier (VRI) is another advanced override technique that uses spatial relationships between objects to enhance identification. VRI defines an object's position relative to other objects, making identification more reliable even when absolute properties change.

• SetTOProperty: Modifies the test object description
• GetTOProperty: Retrieves properties from the test object description
• GetROProperty: Retrieves properties from the runtime object

Implementing these override techniques requires careful consideration to avoid making tests overly complex or brittle. However, when used appropriately, they can significantly improve the reliability of your automated tests in challenging application environments.

Implementing Smart Identification

Smart Identification is UFT's built-in mechanism for handling objects that cannot be identified using standard methods. When UFT fails to identify an object based on its learned description, it can activate Smart Identification as a fallback option to locate the object using alternative properties.

The Smart Identification process involves two main components: base filter properties and associated properties. Base filter properties are the essential properties that an object must have to be considered a potential match. Associated properties are supplementary properties that help narrow down the matches if multiple objects satisfy the base filter criteria.

When Smart Identification is activated, UFT follows a systematic approach to identify the object. First, it discards the learned description and attempts to identify the object using the base filter properties. If multiple objects match the base filter, UFT applies the associated properties to determine the best match.

' Example of enabling Smart Identification for a specific object
Browser("MyApplication").Page("HomePage").WebEdit("username").EnableSmartIdentification = True

While Smart Identification can be a valuable safety net, it should be used judiciously. Over-reliance on Smart Identification can mask underlying issues with object identification and make tests less maintainable. Best practices recommend using Smart Identification as a temporary solution while implementing more robust identification methods.

The effectiveness of Smart Identification depends on properly configuring the base filter and associated properties for different object types. This configuration can be adjusted through the Object Identification settings in UFT, allowing testers to tailor Smart Identification to their specific application requirements.

Advanced Object Identification Strategies

For complex applications with challenging object identification scenarios, advanced strategies can significantly enhance the effectiveness of your UFT automation. One such strategy involves implementing custom identification mechanisms using the UFT Add-in SDK, which allows you to create your own object identification methods tailored to specific technologies or frameworks. This approach requires more technical expertise but can provide unparalleled flexibility for unique testing environments.

Another advanced strategy involves creating hierarchical identification models that prioritize properties based on their likelihood of remaining consistent across application versions. By establishing a tiered approach to object identification, you can create tests that are more resistant to UI changes while maintaining their ability to accurately locate objects. This strategy often involves combining multiple identification methods and implementing fallback mechanisms when primary methods fail.

' Advanced identification with hierarchical approach
Function IdentifyObject(objectClass, parentObject)
    On Error Resume Next
    ' Try identification with primary properties
    Set primaryDesc = Description.Create()
    primaryDesc("micclass").Value = objectClass
    primaryDesc("id").Value = "primary_id"
    Set result = parentObject.ChildObjects(primaryDesc)(0)
    
    If Err.Number = 0 Then
        Set IdentifyObject = result
        Exit Function
    End If
    
    ' Fallback to secondary properties
    Set secondaryDesc = Description.Create()
    secondaryDesc("micclass").Value = objectClass
    secondaryDesc("name").Value = "secondary_name"
    Set result = parentObject.ChildObjects(secondaryDesc)(0)
    
    Set IdentifyObject = result
End Function

Implementing these advanced strategies requires a deep understanding of both UFT and the application under test. However, the investment in developing these capabilities can pay significant dividends in terms of test stability, maintainability, and coverage of complex scenarios.

Best Practices for Object Identification in UFT Projects

Implementing effective object identification strategies is crucial for the success of any UFT automation project. By following best practices, you can create tests that are reliable, maintainable, and efficient even as applications evolve over time.

One fundamental best practice is to establish a consistent object identification strategy across your test suite. This involves standardizing the properties used for different object types and documenting your identification approach for future reference. Consistency reduces maintenance overhead and makes it easier for team members to understand and modify tests.

• Use meaningful object names that reflect their purpose
• Prioritize stable properties that are less likely to change
• Regularly review and update object identification methods

Another important consideration is balancing the comprehensiveness of object descriptions with performance. While including more properties can improve identification accuracy, it can also increase the size of the Object Repository and slow down test execution. Finding the right balance is key to creating efficient tests.

For applications with dynamic objects, consider implementing hybrid approaches that combine multiple identification techniques. For example, you might use Descriptive Programming for frequently changing objects while maintaining a core set of objects in the Object Repository for stable elements.

Regular maintenance of your Object Repository is also essential. As applications evolve, objects may change or become obsolete, requiring updates to their identification properties. Implementing a process for periodic review and cleanup ensures your test infrastructure remains aligned with the application.

Finally, leverage UFT's identification capabilities such as ordinal identifiers and Smart Identification as safety nets rather than primary identification methods. These features should complement well-designed object identification strategies rather than replace them.

Conclusion

Object identification in UFT forms the foundation of automated testing, determining how the tool recognizes and interacts with application elements. By understanding both default and custom identification methods, testers can create more reliable, maintainable, and efficient automated tests. Mastering object identification techniques, including override strategies and Smart Identification, is essential for handling complex applications and dynamic UI elements.

As applications continue to evolve with more dynamic content and complex UI structures, the importance of sophisticated object identification methods grows. Implementing a combination of standard mechanisms, custom approaches, and override techniques provides the flexibility needed to maintain robust test automation frameworks.

The key to successful object identification lies in understanding your application's structure, anticipating potential changes, and implementing strategies that balance accuracy with maintainability. By investing time in developing effective identification methods, you can create tests that not only work reliably today but can also adapt to future changes in your application.

Ultimately, mastering object identification in UFT is about creating a sustainable automation framework that delivers consistent value over time. With the techniques and best practices outlined in this guide, you can build tests that accurately interact with application elements while remaining resilient to changes, ensuring the long-term success of your automation efforts.

Frequently Asked Questions

• What is object identification in UFT?
  Object identification in UFT is the fundamental process through which the test automation tool recognizes and interacts with various UI elements within an application. It involves capturing properties of objects to create test object descriptions used during playback.
• When should I use custom identification methods?
  Custom identification methods should be used when standard object identification methods fall short, particularly when dealing with web applications that use dynamic content, frameworks with auto-generated IDs, or complex UI structures where default properties may not provide sufficient uniqueness.
• What are override techniques in UFT?
  Override techniques in UFT provide additional flexibility for object identification by allowing testers to modify or supplement the default identification process. Common techniques include using programmatic object descriptions, SetTOProperty and GetROProperty methods, and Visual Relation Identifiers.
• How does Smart Identification work in UFT?
  Smart Identification is UFT's built-in mechanism for handling objects that cannot be identified using standard methods. It uses base filter properties and associated properties to locate objects when the learned description fails, providing a fallback option for challenging identification scenarios.
• What are best practices for object identification in UFT?
  Best practices include establishing a consistent object identification strategy across your test suite, using meaningful object names, prioritizing stable properties, implementing hybrid approaches for dynamic objects, and regularly maintaining your Object Repository to ensure alignment with evolving applications.