UFT Test Creation Guide: Save & Run

Mastering UFT: Creating, Saving, and Running Your First Test

Unified Functional Testing (UFT) is a powerful automation tool that enables testers to create robust test scripts for validating software applications. Understanding how to effectively create, save, and run tests in UFT is fundamental for any QA professional looking to enhance their testing capabilities. Creating your first test in UFT involves recording your actions, saving the test properly, and then running it to validate your application's functionality.

Understanding UFT and Its Importance in Testing

Unified Functional Testing, formerly known as QuickTest Professional (QTP), is a comprehensive automated functional testing solution that supports the testing of web, desktop, and mobile applications. UFT combines the power of keyword and scripting interfaces to create and maintain automated tests for a wide variety of applications. The tool's ability to record user interactions and convert them into reusable test scripts makes it accessible to both technical and non-technical users.

As organizations increasingly adopt automation to improve testing efficiency, understanding how to create, save, and run tests in UFT becomes essential for QA professionals. The process of creating your first test in UFT is straightforward yet powerful, allowing both technical and non-technical team members to contribute to the testing effort.

UFT uses a keyword-driven approach combined with VBScript for scripting capabilities, making it accessible to a broad range of users. The ability to record user interactions and convert them into reusable test components is one of UFT's most valuable features. When creating your first test, you'll discover how UFT captures objects, methods, and properties to generate test steps that can be customized and enhanced as needed.

The importance of UFT in modern testing environments cannot be overstated. As software development cycles become increasingly agile, the need for efficient, automated testing solutions grows. UFT provides the flexibility to create tests that can be easily updated when application changes occur, reducing maintenance overhead. Its integration with other tools in the Micro Focus ecosystem, such as ALM (Application Lifecycle Management), further enhances its value by providing a complete testing solution from requirements to execution.

Key benefits of UFT include:

• Support for multiple technologies and platforms
• Integration with various development environments
• Rich set of checkpoints for validating application behavior
• Ability to create reusable components and functions

By mastering UFT, testers can significantly increase their productivity and coverage, ensuring higher quality software releases with less manual effort.

Setting Up Your First Test in UFT

Before you can begin creating tests in UFT, it's essential to properly configure your environment. The first step involves installing UFT on your machine and ensuring that your system meets the minimum requirements. Once installed, you'll need to activate your license and configure the necessary add-ins for the technologies you plan to test.

When launching UFT for the first time, you'll be greeted with a blank workspace. The interface consists of several key components:

• The menu bar and toolbar at the top
• The Keyword View, which displays test steps in a table format
• The Expert View, which shows the corresponding script code
• The Test Settings dialog, where you can configure various test options

Before recording your first test, it's crucial to define your test objectives and prepare your test environment. This includes:

• Identifying the specific functionality you want to test
• Ensuring the application under test is in a known state
• Determining the data you'll need for your test cases

Proper preparation at this stage will save you significant time later and ensure your tests are reliable and maintainable. Take the time to familiarize yourself with UFT's interface and explore the various options available in the Test Settings dialog. Understanding these settings now will make your testing process more efficient and effective in the long run.

When creating your first test in UFT, proper setup is crucial for a smooth testing experience. Begin by launching UFT and selecting "New" from the File menu or clicking the "New" button on the toolbar. This action opens the Test Settings dialog, where you can configure various parameters for your test environment. When creating your first test, it's important to select the appropriate add-ins that match your application's technology stack, such as Web, .NET, Java, or SAP.

The Test Settings dialog allows you to specify details like the test name, location, and associated resources. You can also configure parameters for object identification, run settings, and various other options that will affect how your test behaves during execution. For beginners, it's advisable to use the default settings initially and then explore customization options as you become more familiar with UFT.

Once your test settings are configured, UFT presents you with the Keyword View and Expert View panels. The Keyword View displays your test steps in a table format with columns for item, operation, value, and documentation, making it easy to understand and modify test steps without scripting knowledge. The Expert View, on the other hand, shows the VBScript code equivalent of your test steps, providing more advanced users with direct access to the underlying automation logic.

When creating your first test, you'll likely spend most of your time in the Keyword View, which offers a visual representation of your test steps. This intuitive interface allows you to add, delete, or modify test actions by simply selecting cells in the table. As you progress in your UFT journey, you may find yourself switching between views to leverage the strengths of each representation.

Recording Your Test Actions

Recording is the most fundamental method for creating your first test in UFT. The recording process captures your interactions with an application and automatically generates corresponding test steps. To begin recording, click the Record button on the UFT toolbar or navigate to Automation > Record and Set Tracking. This action opens the Record and Run Settings dialog, where you can specify the application you want to test and choose between recording modes such as Analog or Low Level Recording.

For most web application testing, Normal Recording mode is sufficient. This mode records operations like clicks, text input, and selections as high-level operations on recognized objects. As you interact with your application during recording, UFT identifies the objects using its Object Repository and generates test steps in the Keyword View. Each recorded action appears as a row in the table with corresponding VBScript code visible in the Expert View.

• Key recording tips:
• Close unnecessary applications before recording to avoid capturing unintended actions
• Perform actions at a moderate pace to ensure all steps are captured correctly
• Use meaningful names for objects when prompted by UFT to improve test readability

When creating your first test, you may encounter situations where UFT fails to recognize certain objects. In such cases, you can use the Object Spy tool to investigate the object's properties and methods. The Object Spy allows you to highlight objects in your application and view their identification properties, helping you understand why UFT might be having trouble recognizing them.

After completing your recording session, click the Stop button to end the process. Your test now contains the recorded steps, which you can review and modify as needed. This is an excellent opportunity to familiarize yourself with both the Keyword View and Expert View, understanding how each recorded action translates between the visual table and the underlying script.

Here's an example of how a recorded action might appear in both views:

Keyword View:

| Item | Operation | Value | Documentation |

|------|-----------|-------|---------------|

| Browser("MyApp").Page("Login").WebEdit("username") | Set | "testuser" | Sets username field |

| Browser("MyApp").Page("Login").WebButton("Submit") | Click | | Clicks submit button |

Expert View:

Browser("MyApp").Page("Login").WebEdit("username").Set "testuser"
Browser("MyApp").Page("Login").WebButton("Submit").Click

Saving Tests in UFT - Best Practices

Properly saving your test is a critical step in the UFT testing process that ensures your work is preserved and can be executed later. When creating your first test, UFT prompts you to save the test file with a .mts extension, which is the standard format for UFT tests. It's important to choose a logical naming convention and save your test in an organized directory structure to facilitate easy retrieval and management.

The Save Test dialog provides options for saving not just the test itself but also associated resources such as object repositories, function libraries, and shared object repositories. When creating your first test, you might not be using these advanced features, but as your testing needs evolve, understanding how to manage these resources becomes essential.

• Best practices for saving tests:
• Use descriptive names that clearly indicate the test's purpose
• Implement a consistent naming convention across your test suite
• Save tests in version control systems to track changes and enable collaboration
• Regularly backup your tests to prevent data loss

When creating your first test, you may also want to consider saving checkpoints during the recording process. Checkpoints allow you to verify expected results during test execution, such as checking for the presence of text or validating object properties. UFT offers various checkpoint types including standard, image, table, and text checkpoints, each serving different verification needs.

For more complex testing scenarios, you might need to save your test with associated external resources such as function libraries or object repositories. Function libraries contain reusable VBScript functions that can be called from multiple tests, while object repositories store information about the objects in your application. When creating your first test, you might not need these features, but they become invaluable as your automation framework matures.

Remember that saving your test is not just about preserving your work—it's about creating a reusable asset that can be maintained and extended over time. As you become more proficient in UFT, you'll develop your own best practices for saving tests that align with your organization's testing methodology and requirements.

Here's an example of how to create a simple checkpoint in your test:

' Create a text checkpoint
Browser("MyApp").Page("Welcome").Check CheckPoint("WelcomeText"), "Text=Welcome to MyApp"

' Create a standard checkpoint to verify an object exists
Browser("MyApp").Page("Dashboard").WebButton("Logout").Exist 2, True

Running Tests in UFT - Execution Options

Once you've created and saved your test, the next step is to execute it and observe the results. UFT provides multiple options for running tests, allowing you to choose the method that best suits your testing needs. When creating your first test, you'll likely start with the simplest execution method and then explore more advanced options as you become more familiar with the tool.

The most basic way to run a test is to click the Run button on the UFT toolbar or navigate to Automation > Run. This action executes the test using the current settings and displays the results in a dedicated results window. During execution, UFT replays the recorded steps, interacting with your application just as you did during the recording phase. For beginners, this is the most straightforward method for running tests and validating functionality.

For more control over test execution, UFT offers the Run from Step option, which allows you to execute your test starting from a specific step. This is particularly useful when debugging issues or when you only want to test a portion of your test case. When creating your first test, you might not need this feature immediately, but it becomes invaluable as your tests become more complex.

• Test execution options:
• Run from Test: Executes the entire test from start to finish
• Run from Step: Starts execution from a specific step
• Run Step by Step: Executes one step at a time, allowing for detailed observation
• Debug Mode: Runs the test with breakpoints for debugging purposes

When creating your first test, you may also want to consider using UFT's testing features such as parameters and data tables. Parameters allow you to pass different values to your test steps, enabling data-driven testing where the same test logic can be executed with multiple input sets. The Data Table, accessible via the Data Table tab in UFT, provides a spreadsheet-like interface where you can manage test data.

For teams working in collaborative environments, UFT offers integration with ALM (Application Lifecycle Management), allowing tests to be scheduled and executed as part of a continuous integration pipeline. When creating your first test, you might not be using ALM integration, but understanding this capability prepares you for more advanced testing scenarios in professional settings.

As you run your tests, pay close attention to the results window, which provides detailed information about test execution including passed and failed steps, error messages, and execution time. This information is crucial for identifying issues and improving your tests over time.

Here's an example of how to implement parameterization in your test:

' Using test parameters
username = DataTable("Username", dtGlobalSheet)
password = DataTable("Password", dtGlobalSheet)

Browser("MyApp").Page("Login").WebEdit("username").Set username
Browser("MyApp").Page("Login").WebEdit("password").Set password
Browser("MyApp").Page("Login").WebButton("Submit").Click

Analyzing Test Results and Troubleshooting

After running your test in UFT, analyzing the results is essential to understand whether your application is functioning as expected and to identify any issues that need attention. The Test Results window provides comprehensive information about test execution, including a summary of passed and failed steps, error details, and execution time. When creating your first test, learning to interpret these results is a critical skill that will help you improve your testing effectiveness.

The Test Results window displays a hierarchical view of your test execution, with the root level showing the overall test status and child nodes showing individual test steps and their outcomes. Passed steps appear with green icons, while failed steps display red icons with error messages. When creating your first test, you might encounter several failed steps due to objects not being found or unexpected behavior in your application.

For more detailed analysis, you can expand each test step to view additional information such as the exact error message, the object that was involved, and the values used in the operation. When creating your first test, this level of detail can help you understand why a particular step failed and how to fix it. UFT also provides a "Step Into" debugging option that allows you to execute your test step by step, making it easier to pinpoint the exact location of an issue.

• Common test issues and solutions:
• Object not found: Check object properties in Object Repository and update if necessary
• Synchronization problems: Add wait statements or increase object synchronization timeout
• Parameter errors: Verify data table values and parameter references
• Environment dependencies: Ensure test settings match the execution environment

When creating your first test, you may also want to use UFT's recovery scenarios feature to handle unexpected events during test execution. Recovery scenarios define actions to take when specific errors occur, such as closing unexpected pop-up windows or handling application crashes. This feature can significantly improve the reliability of your tests by making them more resilient to unexpected situations.

As you analyze test results, pay attention to patterns in failures that might indicate systematic issues with your application or testing approach. When creating your first test, you might need to refine your object identification settings or add additional verification points to improve test reliability. Remember that test analysis is an iterative process, and each test run provides valuable information for improving both your tests and your application.

Here's an example of implementing a recovery scenario in your test:

' Using recovery scenarios to handle unexpected pop-ups
If Browser("MyApp").Dialog("Warning").Exist(2) Then
    Browser("MyApp").Dialog("Warning").WinButton("OK").Click
    ' Add wait for the pop-up to close
    Wait(2)
End If

Advanced Tips for Test Management

As you become more comfortable creating your first test in UFT, you'll want to explore advanced features that can enhance your testing efficiency and effectiveness. These features include test parameterization, reusable actions, and integration with other testing tools. When creating your first test, you might not need these advanced capabilities, but understanding them prepares you for more sophisticated testing scenarios.

Test parameterization allows you to execute the same test with multiple sets of data, making your tests more comprehensive and reducing the need to create duplicate tests. When creating your first test, you can start with simple parameterization using the Data Table and gradually progress to more complex data-driven testing approaches. UFT supports various parameter types including test parameters, action parameters, and environment variables, each serving different needs in your testing strategy.

Reusable actions are another powerful feature that allows you to create modular test components that can be called from multiple tests. When creating your first test, you might not need to use reusable actions immediately, but as your test suite grows, this feature can significantly reduce maintenance effort and improve test consistency. UFT distinguishes between reusable actions and external actions, with reusable actions being part of the same test file while external actions are stored in separate test files.

For teams working on large-scale testing projects, UFT's integration with ALM (Application Lifecycle Management) provides centralized test management capabilities. This integration allows you to store tests in ALM, manage test requirements, track defects, and generate comprehensive reports. When creating your first test, you might be working locally without ALM integration, but understanding this capability prepares you for enterprise-level testing environments.

• Advanced test management practices:
• Implement a consistent naming convention for tests and actions
• Use version control for test assets to track changes and enable collaboration
• Create documentation for complex tests to maintain knowledge over time
• Regularly review and refactor tests to improve maintainability

As you progress beyond creating your first test, consider exploring UFT's extensibility options such as adding-in custom components or integrating with external libraries. These advanced features allow you to tailor UFT to your specific testing needs and leverage existing automation investments. Remember that effective test management is not just about creating tests but also about maintaining them over time as applications evolve.

Here's an example of creating a reusable function in a function library:

' Function to login to the application
Function LoginToApplication(username, password)
    Browser("MyApp").Page("Login").WebEdit("username").Set username
    Browser("MyApp").Page("Login").WebEdit("password").Set password
    Browser("MyApp").Page("Login").WebButton("Submit").Click
    
    ' Verify login was successful
    If Browser("MyApp").Page("Dashboard").Exist(10) Then
        Reporter.ReportEvent micPass, "Login", "Successfully logged in as " & username
    Else
        Reporter.ReportEvent micFail, "Login", "Failed to login as " & username
    End If
End Function

' Calling the function from your test
Call LoginToApplication(DataTable("Username", dtGlobalSheet), DataTable("Password", dtGlobalSheet))

Conclusion

Creating your first test in UFT is an exciting step into the world of automation testing, and understanding how to properly save and run tests is fundamental to your success. By following the practices outlined in this guide, you'll be able to create reliable, maintainable tests that effectively validate your application's functionality. As you continue to develop your UFT skills, remember that test automation is both a science and an art, requiring both technical knowledge and creative problem-solving.

The journey of creating your first test in UFT opens up numerous possibilities for improving testing efficiency and effectiveness. Whether you're testing web applications, desktop software, or mobile devices, UFT provides the tools you need to create comprehensive automation solutions. As you gain experience, you'll discover that proper test organization, maintenance, and analysis are just as important as the initial creation and execution of tests.

In today's rapidly evolving software development landscape, automation testing with tools like UFT is becoming increasingly essential. By mastering the fundamentals of creating, saving, and running tests in UFT, you're positioning yourself as a valuable contributor to the quality assurance process. Continue to explore UFT's features, stay updated with best practices, and never stop learning—these habits will ensure your continued success in the field of automation testing.

Frequently Asked Questions

• What is UFT and why is it important for testing?
  Unified Functional Testing (UFT) is a powerful automation tool that enables testers to create robust test scripts for validating software applications. It's important because it improves testing efficiency and coverage in modern software development cycles.
• How do I save my first UFT test properly?
  When saving your UFT test, use a descriptive name that clearly indicates the test's purpose and implement a consistent naming convention. Save your test in an organized directory structure and consider using version control systems to track changes and enable collaboration.
• What are the different options for running UFT tests?
  UFT offers multiple execution options including Run from Test (executes entire test), Run from Step (starts from a specific step), Run Step by Step (executes one step at a time), and Debug Mode (runs with breakpoints for debugging purposes).
• How can I troubleshoot failed UFT tests?
  When troubleshooting failed tests, check object properties in the Object Repository, verify synchronization settings, ensure parameter references are correct, and confirm environment dependencies match. Use the Test Results window to identify specific error messages and the exact location of failures.