Mastering Micro Focus QTP / UFT: A Comprehensive Guide to Standard and Image Checkpoints

Introduction and Main Facts

In the dynamic landscape of automated software testing, validation mechanisms form the bedrock of reliable quality assurance. HP QuickTest Professional (QTP)—subsequently known as Micro Focus Unified Functional Testing (UFT)—has long provided robust utilities designed to verify the operational integrity of application objects. At the core of this verification process are checkpoints: specific validation points embedded directly into a test script to evaluate whether an application’s runtime object attributes match predefined expectations, ultimately determining the PASS or FAIL status of a test execution.

Building upon foundational lessons covering the broad taxonomy of QTP checkpoints, this tutorial zeroes in on two critical validation instruments: Standard Checkpoints and Image Checkpoints. While standard checkpoints evaluate general object properties—such as visibility, state, and textual values—image checkpoints extend this capability into the visual domain, ensuring that graphical assets rendered in the Application Under Test (AUT) conform to strict graphical and property-based standards.

Understanding how to deploy, configure, and manage these checkpoints is essential for automation engineers aiming to build resilient, self-checking scripts capable of catching subtle regressions in user interfaces.

Chronology: The Evolution of Verification in Automated Testing

The methodology of automated validation has matured alongside web and desktop architectures. Historically, early automation testing tools relied heavily on rudimentary coordinate-based clicks and basic text-string comparisons.

• The Early Era of Scripting: In initial iterations of test automation, validation was largely a manual code-writing exercise where testers had to manually extract object properties via script commands and write conditional statements (If...Then) to evaluate success. This process was time-consuming and prone to maintenance bottlenecks whenever an application’s underlying Document Object Model (DOM) shifted.
• The Introduction of Checkpoints in QTP: To streamline this workflow, HP integrated native "Checkpoints" into QuickTest Professional. This allowed testers to graphically select elements during recording or playback phases, abstracting the complex underlying script generation.
• Refining Property and Visual Checks: Over successive versions, QTP expanded checkpoints from simple text verification to encompass complex web tables, XML structures, accessibility properties, and deep pixel-level image comparisons. Today, mastering both standard property checks and visual image validations remains a core competency for legacy QTP/UFT maintainers and enterprise migration engineers alike.

Supporting Data: Understanding Standard Checkpoints

A Standard Checkpoint is the most versatile verification tool in QTP. It evaluates the property values of an application object—such as web buttons, edit boxes, static text, or web tables—against expected baseline data during runtime.

Key Characteristics of Standard Checkpoints

1. Property Validation: It is fundamentally used to inspect and verify dynamic object properties.
2. Runtime Comparison: Expected property values defined at design time are evaluated against actual runtime values.
3. Flexible Insertion Points: Checkpoints can be embedded during a live recording session or added post-recording via editing interfaces.
4. Active Screen Dependency: Testers can utilize QTP’s Active Screen to drop checkpoints, provided the screen captured sufficient object data during the recording phase.
5. Dynamic Modifying Capabilities: Property criteria can be updated at any time via the Checkpoint Properties dialog box.
6. Repository Integration: Every newly created checkpoint is automatically stored in the local object repository, with the flexibility to migrate to a shared object repository.
7. Environment Agnostic: They are supported across all environments, provided the appropriate application add-ins (such as Web, .NET, or ActiveX) are pre-loaded.

The Critical Role of Active Screen Data

A common pitfall for novice automation engineers involves the Active Screen’s data-capture settings. For instance, if an automation script records a login sequence—entering a username and password and clicking "OK"—the Active Screen may be configured to store data exclusively for the interacted objects rather than the entire page layout.

If a tester subsequently attempts to insert a standard checkpoint on a neighboring "Cancel" button using the Active Screen, the operation will fail if that object’s state data was never captured. Consequently, ensuring that the Active Screen records comprehensive page context is a prerequisite for successful offline checkpoint insertion.

Step-by-Step Implementation: Inserting a Standard Checkpoint During Recording

1. Initiate the Checkpoint Menu: Once a recording session is active, navigate to the menu bar and select Insert -> Checkpoint. Alternatively, click the dedicated Standard Checkpoint icon on the toolbar.
2. Review Applicable Options: QTP will present a context-sensitive list of valid checkpoints corresponding to the selected or active test step.
3. Select Checkpoint Type: Choose "Standard Checkpoint" from the list of options.
4. Isolate the AUT Object: The QTP interface temporarily minimizes, allowing the user to click and target the specific object within the Application Under Test.
5. Configure Object Selection: Upon selecting the target object, a confirmation dialog appears detailing the object hierarchy. Click OK to proceed to the primary configuration screen.
6. Define Target Properties: The Checkpoint Properties dialog box opens. Here, testers select which properties to evaluate (e.g., name, enabled, visible). Properties can be set to constant values or dynamically parameterized.
7. Configure Timeouts: Set the optional timeout parameter, which instructs QTP to wait a specified number of seconds for an object to reach a desired property state before executing the validation.
8. Save and Review: Finalize the parameters and click OK. The checkpoint is now embedded within the test flow.
9. Inspect via Views: In the Keyword View, the checkpoint appears as a discrete verification step. In the Expert View, it translates into native VBScript commands, such as:

   Browser("Gmail: Email from Google").Page("Gmail: Email from Google").WebButton("Sign in").Check CheckPoint("Sign in_2")

Inserting Standard Checkpoints During Editing

For tests already recorded, engineers can insert standard checkpoints using two primary workflows:

• Active Screen Editing: Right-click the target object directly within the Active Screen pane and select the option to insert a standard checkpoint, completing the configuration wizard.
• Menu Insertion: Place the cursor at the desired step in the test script, navigate to Insert -> Checkpoint -> Standard Checkpoint, and follow the configuration wizard.

Managing Checkpoint Properties Post-Creation

Checkpoint properties are fully mutable. They can be accessed and modified through three distinct pathways:

1. Initial Creation Prompt: The configuration dialog presented during creation.
2. Keyword View Modification: Right-click an existing checkpoint statement in the Keyword View and select Checkpoint Properties.
3. Object Repository Access: Open the local or shared Object Repository, navigate to the target checkpoint object, and adjust its expected property values directly.

Deep Dive: Image Checkpoints

While standard checkpoints handle alphanumeric and state properties, web applications frequently rely heavily on visual UI assets. An Image Checkpoint is a specialized variant of the standard checkpoint tailored specifically for web images and graphical elements.

The Image Checkpoint Dialog and the "Compare Image Content" Parameter

When an image object is selected for checkpointing, QTP opens an interface closely resembling the standard Checkpoint Properties dialog, augmented with visual-specific settings.

The standout feature of this interface is the Compare Image Content checkbox:

• Unchecked State: QTP validates only the baseline object properties of the image (such as its alt text, source path, height, width, or link destination).
• Checked State: QTP performs a rigorous pixel-level comparison between the runtime image rendered during test execution and the baseline image captured during checkpoint creation.

Handling Discrepancies in Test Results

When pixel comparison is enabled:

• If the runtime image matches the baseline image precisely, the test report logs a single successful image record.
• If a visual discrepancy is detected, the reporting engine displays both the expected baseline image and the actual runtime image side-by-side in the test execution results, allowing engineers to visually pinpoint UI regressions (such as broken layouts, altered color palettes, or distorted logos).

Implementation and Code Representation

Inserting an image checkpoint follows the same navigational logic as a standard checkpoint, except the target must be a graphical element (e.g., a logo or banner).

In the Expert View, an image checkpoint evaluates via the following VBScript syntax:

Browser("Gmail: Email from Google").Page("Gmail: Email from Google").Image("nosign-r42").Check CheckPoint("nosign-r42")

Official Guidelines and Best Practices

To maximize the efficacy of checkpoints in large-scale test automation frameworks, testing architects and quality assurance leads recommend adherence to several official best practices:

• Avoid Over-Checkpointing: Inserting a checkpoint on every single page element inflates execution time and creates fragile test scripts that break under minor cosmetic redesigns. Checkpoints should be reserved for critical business validations, key UI state indicators, and security elements.
• Parameterize Wisely: Where test data fluctuates between iterations, leverage parameterization for checkpoint expected values rather than hardcoding static strings.
• Manage Repositories Strategically: Transition checkpoints from local object repositories to shared object repositories when scaling automation suites across multiple distributed testing teams.
• Ensure Adequate Environment Add-ins: Verify that the correct environment add-ins (e.g., Web, Java, WPF) are initialized prior to launching recording sessions to prevent missing object properties on the Active Screen.

Implications for Enterprise Quality Assurance

The implementation of robust verification strategies using standard and image checkpoints carries profound implications for software delivery lifecycles. By automating complex visual and state validations, enterprises achieve:

1. Reduced Regression Risk: Automated pixel and property checks catch visual defects and broken logic early in the deployment pipeline, safeguarding production environments.
2. Accelerated Feedback Loops: Automated verification reduces the manual testing burden during continuous integration (CI) cycles, allowing development teams to release updates with higher confidence.
3. Enhanced Audit Trails: Detailed test results—complete with side-by-side image comparisons and property-match logs—provide stakeholders with transparent, verifiable metrics regarding application health.

As software systems continue to evolve in complexity, mastering granular testing instruments like QTP/UFT checkpoints remains a critical skill for maintaining uncompromising quality standards across enterprise applications.