TestComplete Enterprise Test Automation: Complete Guide
TestComplete is SmartBear's flagship enterprise test automation platform, covering desktop, web, and mobile applications from a single tool. It's been around since 1999 and remains one of the most widely deployed automation tools in large enterprises, particularly in organizations with significant desktop application testing requirements. This guide covers the platform's architecture, core capabilities, scripting options, and where it fits in a modern QA stack.
What TestComplete Actually Is
TestComplete is a scriptable test automation IDE that combines:
- Object recognition engine — identifies UI elements across WPF, WinForms, Qt, Java Swing, web browsers, and mobile apps
- Record and playback — captures user interactions and generates test scripts
- Keyword-driven testing — lets non-programmers build tests from reusable operations
- Scripting engine — supports JavaScript, Python, VBScript, JScript, C++Script, and DelphiScript
The platform's defining characteristic is its object repository. TestComplete builds a map of your application's UI elements (the "Name Mapping" store), giving tests stable references to objects even when screen positions change. This is what separates it from simple coordinate-based recorders.
Architecture Overview
Test Engine
TestComplete runs on Windows. It launches your application under test (AUT) and injects a monitoring hook that intercepts UI events. This hook is how TestComplete identifies objects, reads properties, and simulates user input at the OS level — not at screen coordinates.
For web testing, TestComplete uses browser extensions (Chrome, Firefox, Edge) that expose the DOM directly, allowing property-based element identification rather than XPath fragility.
For mobile, TestComplete connects to physical devices or emulators via USB or network, using platform-specific accessibility APIs (UIAutomation on Windows, XCUITest on iOS, UIAutomator2 on Android).
Project Structure
A TestComplete project contains:
- Test Items — the execution tree (which tests run, in what order)
- Name Mapping — the object repository mapping logical names to UI properties
- Script Units — code files (.js, .py, etc.)
- Keyword Tests — visual flowchart-style tests
- Data Stores — Excel, CSV, database connections for data-driven testing
- Stores — recorded objects, checkpoints, variables
Projects are stored as XML files in a folder structure, making them compatible with version control systems.
Distributed Testing
TestComplete integrates with SmartBear's TestExecute — a runtime-only license that runs tests without the IDE. This lets you scale execution across multiple machines without purchasing full TestComplete seats for each.
For distributed orchestration, TestComplete integrates with SmartBear's ReadyAPI and with third-party CI tools via command-line execution.
Core Testing Capabilities
Desktop Application Testing
Desktop testing is where TestComplete has the deepest capabilities. It supports:
Technology coverage:
- Win32/Win64 native applications
- .NET (WinForms, WPF, UWP)
- Delphi/C++Builder (VCL, FireMonkey)
- Java AWT/Swing/SWT/JavaFX
- Qt Framework (via the Qt plugin)
- MFC, ATL
- Terminal emulators (via TE Support plugin)
For each technology, TestComplete exposes technology-specific properties. A WPF button isn't just a rectangle — it's an object with Enabled, Visible, Text, IsDefault, and dozens of other properties you can read and assert against.
Object identification:
// Access an object by its mapped name
var loginButton = Aliases.MyApp.MainWindow.LoginForm.btnLogin;
// Read a property
Log.Message("Button text: " + loginButton.Caption);
// Assert a property
if (!loginButton.Enabled) {
Log.Error("Login button should be enabled");
}
// Simulate a click
loginButton.Click();Web Application Testing
TestComplete's web testing works across Chrome, Firefox, Edge, and IE (legacy). It identifies elements by DOM properties rather than coordinates.
Element access:
// Access a web element
var page = Browsers.Item(btChrome).Page("https://app.example.com");
var emailField = page.FindChildEx(["idStr", "email"], ["True"], 10, true);
// Or via Name Mapping (preferred)
var emailField = Aliases.browser.pageLogin.txtEmail;
emailField.SetText("user@example.com");
// Find by XPath
var submitBtn = page.FindElement("//button[@type='submit']");
submitBtn.Click();Cross-browser execution:
// Run the same test in multiple browsers
var browsers = [btChrome, btFirefox, btEdge];
for (var i = 0; i < browsers.length; i++) {
Browsers.Item(browsers[i]).Run("https://app.example.com");
// run test steps
Browsers.Item(browsers[i]).Close();
}Mobile Testing
TestComplete supports iOS and Android testing via:
- Physical devices connected via USB
- iOS simulators and Android emulators
- Cloud devices via integration with BitBar, Kobiton, and other providers
Mobile test scripts use the same object model as desktop and web — elements are identified by properties, not coordinates.
// Access a mobile element
var app = Mobile.Device("iPhone 14").Process("com.example.myapp");
var loginBtn = app.Window("LoginViewController").Button("Log In");
loginBtn.Tap();Name Mapping: The Core Concept
Name Mapping is TestComplete's object repository and the main reason its tests are more maintainable than coordinate-based recorders. Instead of referencing UI elements by their runtime location, you map them to logical names with stable identification criteria.
How It Works
- TestComplete records or you manually capture an element
- The element's properties (class name, text, ID, index, parent path) are stored in Name Mapping
- Your script references the logical name (
Aliases.MyApp.MainWindow.btnSave) - At runtime, TestComplete uses the stored properties to find the actual element
If the element moves on screen, the test still works. If the element's text changes but its ID stays the same, you update Name Mapping in one place — not every test that references it.
Extended Find
When Name Mapping isn't sufficient (dynamic elements, generated IDs), TestComplete provides FindChild and FindChildEx for property-based search:
// Find a button whose text contains "Save"
var saveBtn = Sys.Process("MyApp").FindChildEx(
["ObjectType", "Caption"],
["Button", "Save*"],
5, // search depth
true // match by mask
);Checkpoint Types
Checkpoints are TestComplete's assertion mechanism. Unlike raw if statements in code, checkpoints log pass/fail results with screenshots and property values automatically.
Property checkpoint — verifies a specific property value:
aqObject.CheckProperty(
Aliases.browser.pageCheckout.txtTotal,
"innerText",
cmpEqual,
"$99.99"
);Table checkpoint — compares grid/table data against a stored baseline.
Image checkpoint — pixel-level screenshot comparison with configurable tolerance.
Database checkpoint — compares query results against expected data.
File checkpoint — compares file contents (text, XML, binary).
Data-Driven Testing
TestComplete connects to external data sources to run the same test with multiple input sets.
Excel data:
// Drive a test from an Excel file
var excelFile = DDT.ExcelDriver("C:\\TestData\\users.xlsx", "Sheet1");
while (!excelFile.EOF()) {
var username = excelFile.Value("Username");
var password = excelFile.Value("Password");
var expectedResult = excelFile.Value("ExpectedResult");
// Run test with this row's data
RunLoginTest(username, password, expectedResult);
excelFile.Next();
}
DDT.CloseDriver(excelFile.Name);CSV data:
var csvDriver = DDT.CSVDriver("C:\\TestData\\inputs.csv");Database:
var dbDriver = DDT.ADODriver(
"Provider=SQLOLEDB;Server=dbserver;Database=TestData;Trusted_Connection=Yes;",
"SELECT username, password FROM test_users WHERE active=1"
);Keyword Testing
Keyword tests let QA analysts who don't write code build automation by connecting reusable operations visually.
A keyword test is a sequence of operations:
- Run Script Routine — call a JavaScript/Python function
- Call Object Method — invoke a method on a mapped object
- Set Variable Value — assign a value
- If...Then — conditional branching
- Loop — iteration
- Log Message — write to the test log
The keyword test editor shows operations as rows in a table. Analysts can parameterize operations, connect them to data sources, and nest tests.
Under the hood, keyword tests compile to code — you can switch to code view to see the generated script and edit it directly.
Test Organization and Execution
Test Items Tree
TestComplete's execution model is a tree of Test Items. Each item references either a keyword test or a script function. You configure:
- Execution order — sequential or parallel
- Stop on failure — whether to abort the suite if one test fails
- Iterations — how many times to run the item
- Timeout — maximum execution time
Running Tests
From the IDE: Press F9 or click Run. TestComplete executes the selected test items, capturing a full log.
From command line (for CI):
TestComplete.exe "C:\Tests\MyProject.pjs" /run /exit /exportlog:"C:\Results\log.xml"Or via TestExecute (runtime-only license):
TestExecute.exe "C:\Tests\MyProject.pjs" /run /exit /exportlog:"C:\Results\log.xml" /SilentModeTest Log
TestComplete generates a hierarchical log with:
- Pass/fail status for every checkpoint
- Screenshots at each step (configurable)
- Timing data
- Error messages with stack traces
- System info (OS, screen resolution, process list)
Logs export to HTML, XML, MHT, and JUnit XML format.
When TestComplete Makes Sense
TestComplete is the right choice when:
- You have desktop applications that modern web-only tools can't reach (WPF, WinForms, legacy Win32)
- You have mixed technology stacks — one tool covering desktop + web + mobile reduces overhead
- Your team has limited coding skills — keyword tests lower the barrier to automation
- You're already in the SmartBear ecosystem — TestComplete integrates natively with ReadyAPI, Zephyr, and TestRail via SmartBear
TestComplete is probably overkill when:
- You're testing web-only applications — Playwright or Cypress are faster and cheaper
- You need open-source compatibility — TestComplete is proprietary and expensive
- Your team is code-first — the IDE overhead doesn't justify the benefit for engineers who prefer writing raw Selenium or Playwright
Licensing and Cost
TestComplete is licensed per seat (per concurrent test execution node). SmartBear doesn't publish list prices publicly — they require a sales conversation. Historical market pricing runs $3,000–$8,000 per seat annually for the full platform.
Additional costs:
- TestExecute — runtime-only license for CI execution nodes (less expensive than full TestComplete)
- SmartBear ID — required for license activation, ties to user accounts
- Plugins — Qt, SAP, Oracle Forms, Terminal Emulator support are sold as add-ons
Enterprise agreements typically include volume discounts and SmartBear's support tiers.
Alternatives Worth Knowing
For context on where TestComplete sits in the market:
- Ranorex — similar desktop + web coverage, comparable price point, used by similar enterprise segments
- Tricentis Tosca — model-based approach, more expensive, stronger in SAP/enterprise ERP testing
- Playwright/Selenium — web-only, open-source, lower cost, preferred for greenfield web projects
- Appium — open-source mobile automation, more setup work but no license cost
- UFT One (Micro Focus) — TestComplete's closest legacy competitor, strong in HP/Micro Focus shops
Summary
TestComplete's strengths are desktop coverage, technology breadth, and the keyword testing layer that makes automation accessible to non-coders. Its weaknesses are cost, Windows-only runtime, and the learning curve of the IDE for teams that would rather write code in their existing editors.
For enterprises with desktop applications and mixed QA skill levels, TestComplete is often the practical choice. For pure web teams, there are better-fit tools that cost less and integrate more naturally with developer workflows.
If you need to test a legacy desktop application alongside a web frontend and a mobile app, and your QA team includes both manual testers and developers, TestComplete is worth a serious evaluation.