Bridging the Gap: Automating Green Screen Testing with the Host Access Class Library

While the modern tech landscape is dominated by sleek web applications, microservices, and mobile-first designs, a silent workhorse still powers the core operations of global finance, insurance, and logistics: the mainframe. The 3270 and 5250 terminal interfaces—affectionately (or notoriously) known as "green screens"—are robust and lightning-fast. However, integrating them into modern CI/CD pipelines and automated testing frameworks presents a unique challenge.

Standard web testing tools like Selenium or Playwright are useless here. You cannot inspect the DOM of a terminal emulator. Relying on optical character recognition (OCR) or coordinate-based robotic process automation (RPA) is often brittle and painfully slow.

This is where the Host Access Class Library (HACL) comes in. HACL provides a robust, object-oriented API for interacting programmatically with host emulator sessions, turning flaky UI interactions into reliable, deterministic code.

What is HACL?

The Host Access Class Library (HACL) is a set of APIs typically provided by enterprise emulator software (such as IBM Personal Communications, IBM Host On-Demand, or Micro Focus). Rather than simulating mouse clicks on a screen, HACL allows developers to directly interface with the memory of the terminal emulator.

Because HACL communicates with the emulator's internal state, it reads text exactly as the mainframe sends it and injects keystrokes directly into the session stream. This guarantees precision.

The Three Pillars of HACL

To build an automation framework, you only need to understand three core HACL objects:

ECLSession (The Connection): This is your gateway. It establishes and manages the connection to a specific host session (often identified by a letter, like Session 'A').
ECLPS (Presentation Space): This represents the actual grid of the terminal screen (typically 24 rows by 80 columns). You use the Presentation Space to read text from specific coordinates, search for strings, and send keystrokes to input fields.
ECLOIA (Operator Information Area): The OIA is the status bar at the bottom of a terminal. In automation, it is critical for synchronization. Mainframes process data at variable speeds; the OIA tells you when the system is busy (keyboard locked) and when it is ready for the next input.

Building the Automation Workflow

Automating a green screen workflow generally follows a standard pattern: Connect, Wait, Input, and Validate. Here is a conceptual look at how this logic is structured using HACL.

1. Establishing the Connection

First, your script must attach to an active terminal session.

// Initialize a new session object targeting Session 'A'
ECLSession session = new ECLSession("A");

// Connect to the presentation space and OIA
ECLPS ps = session.GetPS();
ECLOIA oia = session.GetOIA();

2. The Golden Rule: Always Wait for the System

The most common cause of flaky green screen tests is sending keystrokes before the mainframe is ready to accept them. You must wait for the keyboard to unlock.

// Wait up to 10 seconds for the input inhibited indicator to clear
boolean isReady = oia.WaitForInputReady(10000); 

if (!isReady) {
    throw new Exception("Host timeout: Keyboard remains locked.");
}

3. Navigating and Inputting Data

Once the system is ready, you can interact with the screen. Mainframe navigation relies heavily on function keys (F1-F12), Tab, and Enter. HACL uses specific mnemonics for these (e.g., [enter], [pf3]).

// Move the cursor to Row 5, Column 20
ps.SetCursorPos(5, 20);

// Type a username
ps.SendKeys("SYSADMIN");

// Move to the password field (Row 6, Column 20) and type the password
ps.SetCursorPos(6, 20);
ps.SendKeys("SECUREPWD");

// Send the Enter key to submit the screen
ps.SendKeys("[enter]");

4. Validating the Screen (Assertions)

After navigating, you need to verify that the application reached the correct state. You can extract text from specific coordinates to assert success.

// Wait for the next screen to load
oia.WaitForInputReady(10000);

// Read 20 characters from Row 1, Column 30 to check the page title
String pageTitle = ps.GetText(1, 30, 20).trim();

if (pageTitle.equals("MAIN MENU")) {
    System.out.println("Login Test Passed!");
} else {
    System.out.println("Login Test Failed. Current screen: " + pageTitle);
}

Why HACL is the Right Tool for the Job

Adopting HACL for legacy automation brings several distinct advantages to an engineering team:

Deterministic Reliability: Because you are reading from an exact row and column in the presentation space, your tests will not break if the emulator window is resized, minimized, or obscured by another application.
Execution Speed: HACL runs as fast as the mainframe allows. There is no overhead from rendering UIs, taking screenshots, or waiting for OCR algorithms to process pixels.
Seamless CI/CD Integration: HACL scripts (often written in Java, C#, or VBScript) can be wrapped inside standard unit testing frameworks (like JUnit or NUnit). This means your mainframe tests can run in your Jenkins or GitHub Actions pipelines right alongside your modern API and web tests.

Final Thoughts

Integrating legacy systems into modern quality assurance practices doesn't require reinventing the wheel or relying on brittle screen-scraping workarounds. By leveraging the Host Access Class Library, teams can interact with mainframe applications programmatically, bringing the stability, speed, and automation of the modern DevOps era to the foundational systems that continue to power the enterprise world.

Elvis