IBM Early Development Testing

Overview

IBM Early Development Testing (EDT) is an extension that lets you create and run isolated unit tests for COBOL programs — without needing a live CICS region, IMS subsystem, or Db2 database.

Note: EDT supports unit test generation for COBOL programs on z/OS using Batch, CICS, SQL/Db2, and subprogram calls. IMS test case generation is not yet supported.

IBM Early Development Testing (EDT) captures or creates all the data a program reads and writes at each interaction point (files, SQL calls, CICS commands, subprogram calls), then packages that data into a COBOL test case you can run entirely on z/OS without middleware dependencies. The Dynamic Test Engine (DTE) replays the captured data so your program executes as if the real subsystems were present.

There are two ways to generate a test:

With IBM Bob — Requires an IBM Bob Premium Package for Z (PPZ) license and IBM Test Accelerator for Z (TAZ) or IBM Pipeline Automation for Z (PAZ) license. IBM Bob's AI assistant analyzes your COBOL source code and generates a complete test case automatically.
With a recording — Run your program in your live z/OS environment while EDT captures the runtime data, then generate a test case from that recording. Requires an IBM Test Accelerator for Z (TAZ) or IBM Pipeline Automation for Z (PAZ) license.

Once a test is generated, you add assertions and mock return values in the test case, then compile and run it directly using the built-in Test Explorer.

Requirements

Development environment

Either:

Visual Studio Code 1.109.0 or later
IBM Bob 2.0 or later (required for IBM Bob Premium Package for Z (PPZ) license features)

Client prerequisites

IBM Z Open Editor — installed automatically as a dependency. Provides the COBOL language server that IBM Early Development Testing (EDT) uses to analyze your source code and locate test points. Create a ZAPP file with a profile of type test.
Zowe Explorer — required to configure and manage Zowe connection profiles for communicating with your z/OS system. Create a Zowe team configuration file with RSE, z/OSMF, or SSH connections. When using a z/OSMF profile to run tests, the extension also looks for a companion SSH profile to execute the EDT CLI on z/OS.
IBM Z Open Debug — required to configure debug profiles and provides the Dynamic Test Engine runtime used to execute tests on z/OS. Add a zOpenDebug profile to your Zowe team configuration file.
Java 21 or later — required to run the Early Development Testing (EDT) Server background service. The extension resolves Java automatically via IBM Z Open Editor; if not found there, it falls back to the system PATH.
IBM Compiled Code Coverage — required if you want to run unit tests with code coverage. This extension contributes the code coverage view.

z/OS prerequisites

Java — Java 17 or later is required on the host.
- The Java location to use on the z/OS host can be configured to be used from the client via an IBM Early Development Testing extension setting. In the Settings, using Gear icon then Settings option, search for "Edt › Run Tests: Java Home Path" or navigate to Extension, IBM Early Development Testing, and find the "Edt › Run Tests: Java Home Path" setting to add the Java home path for specific Java installation on the host to use. To change directly in the settings.json, use setting name edt.runTests.javaHomePath.
- Otherwise, ensure JAVA_HOME is set on the host.
RSE, z/OSMF, or SSH connection — one of these must be available on the z/OS host so the client can connect. RSE and z/OSMF are supported for both recordings and test runs. SSH profiles are supported for test runs only (not recordings).
Dynamic Test Engine (DTE) load library — the DTE runtime must be installed on z/OS and its load library data set configured in the extension settings (edt.dynamicTestEngineLocation, e.g. USER.DTE.DATALOAD). DTE intercepts program execution during recordings and test runs. DTE is part of IBM Debug Engine.
- Remote Debug Service (RDS) — required by IBM Z Open Debug and IBM Compiled Code Coverage to debug and collect code coverage for unit tests.
- Debug Profile Service (DPS) — needed to record data when not using IBM Bob, and to check user licenses. Also used for the Data Collector.
IBM Enterprise COBOL compiler — required on z/OS to compile generated test cases.
- The Compiler location to use on the z/OS host for unit testing can be configured to be used from the client via an IBM Early Development Testing extension setting. In the Settings, using Gear icon then Settings option, search for "Edt › Compile And Link: Cobol Compiler Path" or navigate to Extension, IBM Early Development Testing, and find the "Edt › Compile And Link: Cobol Compiler Path" setting to add the path on the host for the Compiler to use. To change directly in the settings.json, use setting name edt.compileAndLink.cobolCompilerPath.
- Otherwise, ensure the compiler is discoverable via COBOL_INSTALL_DIR on the host.
ZOAU (z/OS Open Automation Utilities) — required on z/OS to run test execution commands. Configure the path via edt.runTests.zoauBinPath, or ensure ZOAU_HOME is set on the host.

Licenses

IBM Test Accelerator for Z (TAZ) or IBM Pipeline Automation for Z (PAZ) license — required for recording-based test generation and running tests via the IBM Early Development Testing (EDT) CLI.
IBM Bob Premium Package for Z (PPZ) license — required for IBM Bob-based AI test generation, compilation, file upload, and remote test execution through IBM Bob.
IBM Pipeline Automation for Z (PAZ) license — can be obtained if your primary goal is running unit tests in a CI/CD pipeline.

Getting Started

Glossary

These terms appear throughout the IBM Early Development Testing (EDT) UI, sidebar views, and log messages.

Term	Definition
Test point	A location in your COBOL program where the Dynamic Test Engine (DTE) can intercept execution — file I/O, SQL calls, CICS commands, subprogram calls, or IMS calls. Each test point becomes a callback in the generated test case.
Callback	A named entry point in the generated test case that corresponds to a test point. You add your mocks and assertions inside each callback. Callbacks are visible in the Callbacks for mocks and asserts sidebar view.
Mock	A simulated data value or subsystem response injected at a test point during test execution. Mocks replace real middleware so the program runs in isolation.
Assert	A check written in the test case that verifies a value or program behaviour at a test point. Assertions fail the test if the actual result does not match the expected value.
Recording	A binary file captured during live program execution on z/OS that contains all data exchanged at each test point. The recording is used to seed mock values in the generated test case.
Test case	The generated `.test.cbl` COBOL program that drives test execution. It contains unit tests, callbacks, mocks, and assertions, and is compiled and run on z/OS.
Unit test	An individual test inside a test case. Each unit test executes one program under test. Unit tests start with `PROGRAM-ID. 'TEST_`.
DTE (Dynamic Test Engine)	Part of IBM Debug Engine that executes COBOL unit tests on z/OS by intercepting program execution.
Early Development Testing (EDT) Server	A background Java service started automatically by the extension. It handles various tasks on the client workstation, such as interpreting the .rec recording files and test case generation.
Zowe profile	A saved connection configuration (host, port, username, password) used to communicate with your z/OS system. Managed through Zowe Explorer.
ZAPP	A project configuration file (`zapp.yaml`) that defines connection profiles, test profiles, and settings used when compiling and running tests.
Compile and link	The z/OS process of compiling a COBOL source file and linking the resulting object code into an executable load module.
Load module	The compiled, executable form of a COBOL program stored in a z/OS data set.
JCL (Job Control Language)	The scripting language used to run batch jobs on z/OS. Early Development Testing (EDT) generates JCL when creating batch recordings and running test compilation steps.
Copybook	A reusable COBOL source file containing shared data structure definitions. Copybook locations must be configured so the extension can find them when compiling test cases.

Generating tests with IBM Bob

This workflow uses IBM Bob to analyze your COBOL source code and generate a complete test case without requiring a live program recording. An IBM Bob Premium Package for Z (PPZ) license is required.

Open your COBOL program file (.cbl)
Open the IBM Bob chat panel.
Ask IBM Bob to generate a test — for example:

Generate a test for MYPGM.cbl
IBM Bob analyzes the source code, identifies all test points (file I/O, SQL, CICS, subprogram calls), and generates the test case automatically. This can take up to several minutes.
The generated test case is written to edt-unit-test/<PROGRAM>.test.cbl in your workspace (or the folder configured via defaultTestCaseFolder in your zapp.yaml).
Open the generated file and review the test cases. Each test case corresponds to a scenario IBM Bob identified in your program logic.
Ask IBM Bob to run the tests:

Run tests for MYPGM
Results appear in the Test Explorer (Click on the Activity Bar's Beaker icon to show the Test Explorer).

Generating tests with a recording

This workflow captures live data from a running program on z/OS and uses it to generate a test case pre-populated with real mock values. An IBM Test Accelerator for Z (TAZ) or an IBM Pipeline Automation for Z (PAZ) license is required.

Open your COBOL program file (.cbl)
Right-click the file in the Explorer or editor and select IBM Early Development Testing > Create new unit test.
In the test creation panel, select your recording type:
- Batch — for batch COBOL programs run via JCL.
- CICS — for programs invoked as CICS transactions.
Select your Zowe profile (z/OS connection) and Z Open Debug profile.
Follow the prompts to configure the recording and start it. The extension uploads the recording configuration to z/OS.
Run your COBOL program in its normal production environment. IBM Early Development Testing (EDT) captures data at every test point as the program executes.
Stop the recording from the test creation panel. The recorded data file is downloaded to your local workspace.
With the recording file and COBOL source selected, click Generate to produce the test case. The generated file is written to edt-unit-test/<PROGRAM>.test.cbl.
Open the generated test case. In the Testing panel (Click on the beaker icon in the Activity Bar), the Callbacks for mocks and asserts view populates automatically. The mock data is pre-populated from the recording — add assertions to verify the program's behaviour.
Run the tests from the Test Explorer (Click on the Activity Bar's Beaker icon to show the Test Explorer). Results are displayed per test case.

Running tests

Once your test case is created, you can run it directly, using the Test Explorer.

Open the Test Explorer panel by clicking the Beaker icon in the Activity Bar.
IBM Early Development Testing (EDT) automatically discovers .test.cbl files in your workspace and lists each test case in the tree.
Click the Run button next to an individual unit test, a test case, or the root node to run all tests.
The extension uploads the .test.cbl file to z/OS, compiles the COBOL test file, executes the tests using the Dynamic Test Engine (DTE), and streams results back to the Testing activity View.
Each test case is marked passed or failed in the Test Explorer:
- Passed — all assertions in the test case matched the expected values.
- Failed — one or more assertions did not match. Select the failed test to see a detailed diff of the expected vs. actual data at the failing test point.
- Error — the test could not complete due to a compilation, upload, or runtime error. Check the output panel for details.

To view test points in context while editing your COBOL source, use IBM Early Development Testing > Show/Hide Test Points (right-click a COBOL file or use the command palette). The Callbacks for mocks and asserts and Test points linked to callbacks views in the Testing panel show all test points and their corresponding callbacks across your workspace.

Tip: If code coverage reporting is available in your environment, IBM Early Development Testing (EDT) can register test runs with Z Open Debug to produce line-level coverage results alongside your test output.