With modern software development moving rapidly toward DevOps, CI/CD, and automation-first approaches, test automation tools are evolving to better integrate with developer workflows. UFT Developer, formerly known as Lean Functional Testing (LeanFT), is Micro Focus’s response to this need — bridging the gap between traditional testing and modern development practices.

In this post, we'll explore what UFT Developer is, why it's used, its key features, and how to set up and execute your first automation script using Java and Eclipse.

What Is UFT Developer (LeanFT)?

UFT Developer, or LeanFT, is an automated functional testing tool built for modern development environments. Unlike traditional UFT (Unified Functional Testing), which uses VBScript and a standalone IDE, UFT Developer integrates seamlessly with developer IDEs like Eclipse and Visual Studio, and supports popular languages like Java and C#.

Instead of replacing UFT, it enhances it — allowing automation engineers and developers to collaborate better, leverage modern language ecosystems, and build reliable test suites within CI/CD pipelines.

🧠 Why Use UFT Developer?

UFT Developer (formerly LeanFT) is built for modern development teams that need to automate both modern web/mobile applications and enterprise legacy systems like Oracle Forms, SAP, and other thin-client apps — all from within real programming environments like Java and C#.

🔹 Key Benefits:

➤ Develop Scripts in Java or C#
Use modern programming languages and design patterns with full IDE support (Eclipse, IntelliJ, Visual Studio) — no vendor scripting required.

➤ Accelerate Test Execution with IDE Integration
Write, debug, and execute tests directly inside your IDE, leveraging context-aware autocomplete, reusable test libraries, and version control integration.

➤ Seamless DevOps Integration
Plug into your existing pipelines with support for Git, Jenkins, Maven, Gradle, Azure DevOps, and Dockerized test execution.

➤ Support for Enterprise Apps (Oracle, SAP, Thin Clients)
UFT Developer excels where Selenium and other web tools cannot:

• ✅ Oracle Forms: Automate Java-based forms used in Oracle EBS

• ✅ SAP GUI / Web: Support for SAP NetWeaver, SAP Fiori, SAPGUI

• ✅ Thin-client Java apps: Works with legacy Java AWT/Swing applications

• ✅ Non-DOM UIs: Interact with objects not visible in browser DOM
  
  

➤ Create Tests Alongside Application Code
Keep your automation close to the source — ideal for Agile teams doing shift-left testing and maintaining testable codebases.

UFT Developer bridges the gap between modern Agile automation needs and legacy enterprise platforms — making it ideal for organizations working across Oracle, SAP, custom Java apps, and web/mobile environments.

✨ Key Features of UFT Developer

• Supports modern programming languages: Java and C#

• Compatible with leading IDEs: Eclipse and Visual Studio

• Integrates with DevOps tools: Git, SVN, Jenkins, TFS, Cucumber

• Provides advanced object recognition with descriptive programming

• Works across platforms: Web, Mobile, SAP, Windows apps

• Produces HTML-based test reports with detailed logs and screenshots

🔧 Installation & Setup Guide

To get started with UFT Developer, make sure the following tools are installed:

✅ Prerequisites:

• Java JDK 8 – Download

• Eclipse IDE (2018 version or later) – Download

• Node.js – Download

• Apache Maven – Download & install

• UFT Developer (trial or licensed version) – Download here
  
  

Make sure you install the UFT Developer plugin into your Eclipse IDE for project and object model support.

⚙️ Maven Dependencies

Add the following dependencies in your Maven pom.xml file to work with the UFT Developer SDK:

<dependency>

    <groupId>com.hp.lft</groupId>

    <artifactId>com.hp.lft.sdk</artifactId>

    <version>15.0.1</version>

</dependency>

<dependency>

    <groupId>com.hp.lft</groupId>

    <artifactId>com.hp.lft.report</artifactId>

    <version>15.0.1</version>

</dependency>

<dependency>

    <groupId>com.hp.lft</groupId>

    <artifactId>com.hp.lft.unittesting</artifactId>

    <version>15.0.1</version>

</dependency>

<dependency>

    <groupId>com.hp.lft</groupId>

    <artifactId>com.hp.lft.verifications</artifactId>

    <version>15.0.1</version>

</dependency>

<dependency>

    <groupId>junit</groupId>

    <artifactId>junit</artifactId>

    <version>4.1</version>

</dependency>

🛠️ Writing Your First UFT Developer Script (Java + Eclipse)

Here’s a simple test that launches Chrome, opens Google, and loads the object model.

📁 Sample Project Structure:

MyUFTProject/

│

├── src/

│   ├── com.example.tests/

│   │   └── SampleTest.java

│   │

│   └── com.example.models/

│       └── ApplicationModel.java  <-- Your generated model

│

├── lib/                          <-- SDK jars, if any

├── testng.xml / junit config     <-- Test runner

└── pom.xml / build.gradle        <-- Dependencies & build script

🔷 What is ApplicationModel?

ApplicationModel is typically auto-generated by Micro Focus UFT Developer (formerly LeanFT) using its Application Model feature. It acts as an object repository, allowing you to interact with the application’s UI elements using friendly, readable names.

When you use the Application Model Editor in UFT Developer, it generates a Java class (e.g., ApplicationModel.java) which contains methods and properties representing web elements such as buttons, text fields, links, etc.

🔷 What does new ApplicationModel(browser) do?

• It instantiates the object repository (ApplicationModel) with the current browser instance.

• This links the model to the actual browser you just launched, so that all the objects inside the model can operate on that browser session.
  
  

✅ Requirements for this to work:

1. You must have an ApplicationModel class generated in your project (typically created using the UFT Developer IDE plugin).

2. The browser must be launched and active.

3. LeanFT (UFT Developer) runtime engine must be installed, running, and connected to the IDE.

4. The LeanFT Agent for the browser (e.g., Chrome Agent) must be enabled.

5. Zoom must be set to 100%, because some visual-based operations may fail otherwise.

🧱 1. Generate the Application Model 

Create a new Application Model class (usually done using UFT Developer’s IDE plugin).

🪜 Steps to Create an Application Model in UFT Developer:

💡 Prerequisites

• UFT Developer (LeanFT) is installed.

• IDE plugin (for IntelliJ or Eclipse) is installed and configured. (Eclipse or IntelliJ with UFT Developer plugin) 

• UFT Developer runtime engine is running.

✅ Add an Application Model

In Eclipse:

• Right-click on your src folder or package.

• Select: New → Other → UFT Developer → Application Model

• Name it (e.g., ApplicationModel or GoogleModel)

• Finish.

This creates a .Java class that extends UiModelBase.

✅ Add Pages and UI Elements

• Double-click the new Application Model .java file (or use the graphical editor).

• Add a page (e.g., "GoogleSearchPage").

• Inside that page, add UI elements like:
  searchBox (EditField)
  searchButton (Button)
  
  

You can:

• Use Add → Element and specify properties (tag name, name, id, etc.)

• Or use the Object Identification Center (OIC) to spy and capture objects directly from the browser.
  
  

Assume it generates something like this:

package com.example.models;

import com.hp.lft.sdk.web.Browser;

import com.hp.lft.sdk.web.EditField;

import com.hp.lft.sdk.web.Button;

import com.hp.lft.sdk.web.EditFieldDescription;

import com.hp.lft.sdk.web.ButtonDescription;

public class ApplicationModel extends com.hp.lft.sdk.web.UiModelBase {

    public ApplicationModel(Browser browser) {

        super(browser);

    }

    public GoogleSearchPage googleSearchPage() {

        return new GoogleSearchPage(browser);

    }

    public static class GoogleSearchPage {

        private Browser browser;

        public GoogleSearchPage(Browser browser) {

            this.browser = browser;

        }

        public EditField searchBox() throws Exception {

            return browser.describe(EditField.class,

                    new EditFieldDescription.Builder()

                            .name("q")

                            .tagName("INPUT")

                            .type("text")

                            .build());

        }

        public Button searchButton() throws Exception {

            return browser.describe(Button.class,

                    new ButtonDescription.Builder()

                            .name("btnK")

                            .tagName("INPUT")

                            .type("submit")

                            .build());

        }

    }

}

Once the model is generated, you can use it like: 

ApplicationModel appModel = new ApplicationModel(browser);

appModel.googleSearchPage().searchBox().setText("LeanFT");

appModel.googleSearchPage().searchButton().click();

✅ Summary: Application Model in UFT Developer

• It is code-generated, strongly typed, and IDE-friendly.

• It mimics the role of classic UFT’s Object Repository.

• It improves reusability, maintainability, and readability.

🔧 2. Update Your Test Code to Use the Application Model 

📄 SampleTest.java: 

package com.example.tests;

import com.hp.lft.sdk.ModifiableSDKConfiguration;

import com.hp.lft.sdk.SDK;

import com.hp.lft.sdk.web.Browser;

import com.hp.lft.sdk.web.BrowserFactory;

import com.hp.lft.sdk.web.BrowserType;

import org.junit.After;

import org.junit.Before;

import org.junit.Test;

public class SampleTest {

    Browser browser;

    @Before

    public void setUp() {

        try {

            ModifiableSDKConfiguration config = new ModifiableSDKConfiguration();

            SDK.init(config);

            System.out.println("SDK Initialized");

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    @Test

    public void testGoogleSearch() {

        try {

            browser = BrowserFactory.launch(BrowserType.CHROME);

            browser.navigate("https://www.google.com/");

            System.out.println("Navigated to Google");

            appModel = new ApplicationModel(browser); 

            appModel.googleSearchPage().searchBox().setText("LeanFT");

            appModel.googleSearchPage().searchButton().click();

            Thread.sleep(2000); // Wait for results

            assertTrue("Title should contain 'LeanFT'", browser.getTitle().toLowerCase().contains("leanft"));

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    @After

    public void tearDown() {

        SDK.cleanup();

        System.out.println("Test completed and SDK cleaned up");

    }

}

🧠 Tips

• If btnK (search button) isn’t visible right away, you might need to simulate pressing "Enter" or use a Thread.sleep(1000) before clicking.

• You can also use sendKeys(Keys.ENTER) instead of clicking if needed.

📌 Final Notes

• You can spy objects using the Object Identification Center (OIC) tool that comes with UFT Developer.

• Application Model is excellent for scaling UI automation, especially in large applications.

• Treat each page or screen as a separate class or nested class for modularity.
  
  

✅ Supported Add-ins in UFT Developer Engine

1. Web
   Used to automate web applications running in browsers like Chrome, Edge, or Firefox. It supports standard web technologies including HTML, JavaScript, Angular, React, and more.
   
   

2. Mobile
   Enables automation of native, hybrid, and mobile web applications on Android and iOS. This works in combination with UFT Mobile (formerly Digital Lab).
   
   

3. SAPUI5
   Specifically designed for automating web-based SAP Fiori or SAPUI5 applications. Provides support for controls unique to SAP web apps.
   
   

4. WPF (Windows Presentation Foundation)
   Used for automating modern desktop applications built with Microsoft's WPF technology (.NET framework).
   
   

5. WinForms
   Supports automation of classic Windows Forms applications, typically older .NET desktop apps.
   
   

6. SAP GUI
   Enables automation of SAP’s traditional desktop GUI applications (SAP GUI for Windows). It recognizes SAP-specific controls and allows interaction with them.
   
   

7. Java
   Allows automation of Java-based applications including Swing, AWT, and SWT. Requires proper Java environment configuration.
   
   

8. Terminal Emulators
   Supports automation of host-based applications accessed through terminal emulators. Examples include IBM mainframe systems accessed via HLLAPI, Attachmate, or similar terminal windows.
   
   

🔧 Notes:

• These add-ins must be selected during installation or enabled later through UFT Developer’s configuration.

• Each add-in introduces specific SDK classes (e.g., JavaButton, WpfWindow, SapEditField, etc.) tailored for that technology.

• If object spying or identification isn't working, make sure the required add-in is installed and active, and the application under test matches the technology supported by the add-in.
  
  

🔧 Enterprise Automation Use Cases with UFT Developer

• Oracle Forms
  ✅ Fully supported. UFT Developer can automate Java-based Oracle Forms (commonly used in Oracle E-Business Suite) by leveraging the Java Accessibility API.
  
  

• SAP GUI / SAP Web (Fiori)
  ✅ Supported. Automate both SAPGUI desktop applications and SAP Fiori web interfaces with reliable object recognition and interaction.
  
  

• Thin Clients (Legacy Java Apps)
  ✅ Supported. UFT Developer handles Java AWT/Swing-based applications, making it ideal for legacy enterprise systems.
  
  

• Modern Web Applications (HTML/JS)
  ✅ Supported. Cross-browser testing on Chromium, Firefox, and Edge is fully supported — ideal for modern single-page apps (SPAs).
  
  

• REST APIs
  ✅ Supported with extensions. While UFT Developer doesn’t natively include API testing, it integrates smoothly with Java libraries like Rest Assured, enabling unified test suites across UI and APIs.