Silk (SilkTest / 4Test)

Silk is a family of automated software-testing products whose central member, SilkTest, drives application graphical user interfaces for functional and regression testing. The original engine of the product is 4Test, an object-oriented, C-like fourth-generation language (4GL) that Segue Software designed specifically for quality-assurance work. Where general-purpose languages treat a button or a menu as just another object, 4Test treats the entire application under test as a hierarchy of recognized GUI controls, and turns the act of clicking, typing, and verifying into first-class language constructs. That focus made Silk one of the defining commercial test-automation tools of the late 1990s and 2000s, and—through a chain of acquisitions ending at OpenText—it remains an actively sold product today.

This page covers the Silk product family and the 4Test language together, since for most of Silk’s history the two were inseparable: to automate a test in SilkTest was to write 4Test.

History & Origins

Segue Software and QA Partner

Silk’s roots lie with Segue Software, a company incorporated in California in 1988 and headquartered in Lexington, Massachusetts (Segue reincorporated in Delaware in January 1996). Segue’s GUI test-automation tool was first sold under the name QA Partner. The QA Partner name is documented for roughly 1993 through 1996; the precise first-release year is not firmly established in the surviving public record, so it is best treated as approximate.

What is well-documented is the rebranding: in 1996, QA Partner was renamed Silk Test, establishing the “Silk” brand that the product carries to this day. The scripting language at its heart, 4Test, predated the Silk name and carried over unchanged. The Silk brand thus dates to the 1996 rename, with the underlying QA Partner tool and 4Test language older still.

A Specialized Language for QA

Segue’s official documentation describes 4Test as “an object-oriented fourth-generation language (4GL) designed specifically with the needs of the QA professional in mind.” This was a deliberate departure from the alternative of the era—recording brittle, coordinate-based macros—and from the other alternative of asking testers to write full programs in C or C++. 4Test borrowed C/C++ syntax and a class-and-inheritance object model, but wrapped it around testing primitives: a testcase was a special kind of function with built-in error recovery and results reporting, and the windows and controls of the application under test were declared as objects the script could address by name.

The 4Test Language

4Test is an object-oriented scripting language with explicit data types, classes, objects, and inheritance—Segue’s documentation likens it to C++. A test suite is typically split between script files (.t), which contain the test logic, and include/frame files (.inc), which contain window declarations: the abstraction layer that names and describes the application’s GUI objects.

Testcases and Built-in Types

The simplest unit of 4Test is the testcase, a function-like construct that the runtime wraps with automatic error handling and result logging:

testcase SayHelloWorld ()
  print ("Hello World")

4Test provides primitive types such as STRING, INTEGER, and BOOLEAN, along with user-defined composite types built with LIST OF and enum:

type FILE is LIST OF STRING

type COLOR is enum
  red
  green

Window Declarations and GUI Objects

The distinctive feature of 4Test is that GUI objects are part of the language’s object model. Window declarations in an .inc frame file describe the application’s windows, menus, buttons, and fields, organized into a class hierarchy. A parent class such as Control defines characteristics common to checkboxes, text fields, and pushbuttons, while a class like PushButton defines the methods available on every button. Scripts then address those objects directly:

TextEditor.File.Close.Pick ()
if MessageBox.Exists ()
  // if a confirmation dialog appeared
  MessageBox.No.Click ()  // then dismiss it

Here TextEditor, File, Close, and MessageBox are declared GUI objects, and Pick, Exists, Click, and No are methods or members defined by their classes. Because object identity is declared once in the frame file and reused everywhere, a change to the application’s UI can often be absorbed by editing a single declaration rather than every script.

Design Philosophy

Several principles distinguish 4Test and the Silk approach from general-purpose programming:

The application is a typed object hierarchy. Rather than scripting raw screen coordinates, the tester describes the application’s GUI as classes and objects. Recognition is logical, not positional, so tests survive cosmetic layout changes.

Testing primitives are first-class. The testcase keyword, automatic recovery from unexpected dialogs, and built-in results reporting are language- and runtime-level features, not libraries bolted on afterward. The language is shaped around the QA workflow.

Separation of logic and locators. Splitting .t scripts from .inc window declarations is an early expression of what later test frameworks would call the Page Object pattern—keeping element definitions in one place so test logic stays readable and maintainable.

Familiar syntax, specialized purpose. By adopting C/C++-style syntax and an object model with inheritance, Segue lowered the barrier for engineers who already knew those languages, while keeping the vocabulary domain-specific.

The Silk Product Family

“Silk” is a brand covering several related products, not a single tool:

• SilkTest — functional and regression test automation, the home of 4Test.
• SilkPerformer — load and performance testing (it uses its own scripting language rather than 4Test).
• SilkCentral / Silk Central Test Manager — test management and orchestration.

Classic Agent vs. Open Agent

Modern SilkTest exposes two “agents”—the components that interact with the application under test:

The Classic Agent preserves the original 4Test experience. The Open Agent, introduced as the product modernized, lets teams write tests in mainstream languages: Silk4J integrates with Eclipse for Java, Silk4NET integrates with Visual Studio for C# and VB.NET, and Silk Test Workbench offers a visual, keyword-driven interface backed by VB.NET. (Silk4J and Silk4NET were later rebranded under the “UFT Developer” name.) This dual-agent design let Silk carry its installed base of 4Test scripts forward while courting developers who preferred standard languages and IDEs.

Evolution: A Chain of Acquisitions

After more than a decade as a Segue product, Silk passed through a series of corporate owners:

1. Borland (2006) acquired Segue Software, absorbing SilkTest, SilkPerformer, and SilkCentral into its software-delivery lineup and releasing SilkTest 8.0 with new support for Eclipse-based applications.
2. Micro Focus (2009) acquired Borland, bringing the Silk products under the Micro Focus umbrella, where the Open Agent and the Silk4J/Silk4NET integrations matured.
3. OpenText (2023) completed its acquisition of Micro Focus, effective 31 January 2023, making OpenText the current vendor of Silk Test.

Across these transitions the product retained its name and its 4Test heritage, even as new scripting front-ends and web/mobile object recognition were layered on.

Current Status

Silk Test is actively sold and supported, now marketed as OpenText Silk Test (formerly Micro Focus Silk Test) within OpenText’s functional and regression testing portfolio. The product targets a broad range of technologies—.NET (WinForms and WPF), Java (Swing and SWT), web/DOM applications across major browsers, SAP’s Windows GUI, and mobile platforms.

The latest numbered release that can be confidently verified from public sources is Silk Test 21.0, announced by Micro Focus in late 2020 (reportedly around December 2020); OpenText continues to distribute and support the product, and newer point releases may exist, but version numbers beyond 21.0 should be confirmed against current vendor documentation before being relied upon.

Why Silk Matters

Silk and its 4Test language belong to the first generation of serious commercial GUI test-automation tools. At a time when many teams either tested by hand or recorded fragile pixel-based macros, 4Test offered a genuinely programmable, object-oriented model in which the application under test was a typed hierarchy of named controls. The separation of test logic from window declarations anticipated patterns—like the Page Object model—that are now standard practice in frameworks such as Selenium and its successors.

That a 4Test-scriptable product first branded in 1996 is still sold, three corporate owners later, says something about how durable a well-targeted domain-specific language can be. Even as the industry moved toward open-source automation and mainstream scripting languages, Silk adapted by adding Java and .NET front-ends while keeping its original engine alive for the installed base. For students of test automation, 4Test is a clear, early illustration of a principle that still holds: when a language is designed around the structure of the problem—here, the GUI as an object graph—rather than forcing the problem into a general-purpose language, the resulting tests are easier to write, read, and maintain.