QF-Test

From AI exploration to stable test cases: Best practices for test generation in QF-Test 11

2026-10-15T00:00:00+02:00

QF-Test 11 lets AI agents explore your application and generate a first draft of a test suite. A question we hear a lot from customers evaluating these features is: how do you turn that AI-driven exploration into stable, maintainable test cases, rather than ending up with a skeleton suite full of “AI Instructions”?

AI Instruction nodes are a great prototyping tool, and they can help you get unstuck in a pinch, but they’re not a good foundation for long-term, robust UI testing — you should migrate them to native QF-Test test steps wherever possible.

This post walks through the workflow that works well today, what’s changing with QF-Test 11.1 later this year, and where the current limits are when it comes to AI reading or editing existing suites.

The recommended workflow today (QF-Test 11.0)

The current recommended approach combines the AI-based test planning and generation dialog with QF-Test’s classic recording mechanism:

Use the “Plan and generate tests with AI” dialog to generate an initial suite of test cases with “AI Instructions” from a prompt and a connected application.
Clean up the generated suite: Remove unnecessary steps, clarify instructions and add missing information where needed.
Convert the individual “Test Step” nodes into recorded sequencces via record & replay: Press the “Start recording” button, run a test step, then stop and save the recording. Repeat for every test step. You can use the option “Insert recording at current selection” to streamline the process.
Review and refine the results: You may want to refactor repeating actions into Procedures, put repeating values into variables using Set variable, or insert conditional logic using if and else nodes, or error handling using try/catch. QF-Test offers all kinds of different nodes for structuring and enhancing your test suite.

This “rerecording” approach can be quite powerful when combined with the Procedure call recording mode introduced in QF-Test 11. With it, you can turn AI instructions directly into matching procedures from your existing library:

Who ya gonna call? Auto-generate procedure calls for clean and maintainable tests

In this webinar, we’ll show you how QF-Test 11 can recognize matching procedures from your library while recording sequences and automatically insert the corresponding calls.

The dialog for planning and generating tests with AI.

A freshly generated suite, made up of “AI Instruction” nodes.

One limitation to keep in mind: UI actions performed by the AI agent like clicks, navigation events, keyboard inputs, are picked up automatically by a running recording, but performed checks can not yet be captured this way in QF-Test 11.0.

You don’t have to treat exploration and recording as separate phases. If you keep a recording running during the exploration phase of test generation, every interaction the agent performs is captured as it happens. They are not automaically organized into individual tests, but you can copy and paste them into your generated test where they apply.

What’s coming in QF-Test 11.1 (later this year)

This workflow will become much nicer and more automated starting with QF-Test 11.1:

The suite generator will directly produce recorded nodes where possible, and only fall back to AI Instructions if the required interaction is too complex.
You will be able to convert AI instructions into recordings in bulk, instead of requiring the manual record-and-replay dance for each test step.
Most assertions performed by the AI agent will also be converted into native checks.
New MCP tools (and matching internal tools) will let the AI start and stop recordings, and organize the results into simple procedures and test cases automatically.
A new script API will let you start or unpause recordings programmatically, in case you need more control.

If you’re interested in trying these features early, a pre-release preview build may become available before the general release — reach out to us if you’d like to get involved.

Reading and editing existing test suites

Recording covers adding new content to a suite, but our customers also want the AI to read, explore, and edit existing suites — for example to understand what a suite already tests before extending it, or to refactor it. We’re investigating dedicated solutions for this (MCP tools and internal APIs for structured suite access), but do not have anything available yet.

In the meantime, suites can be explored by external AI agents via their underlying XML file. This works reasonably well for suites that aren’t too large, but it doesn’t scale to big or complex suites.

When experimenting with editing suite XML keep in mind: a suite that has been modified externally — for instance by an AI agent editing the XML outside of QF-Test — can no longer be opened with a free QF-Test evaluation license. Opening an externally modified suite requires a commercial license.

Today, the best path from AI exploration to a stable test suite is: generate a draft with AI, then record alongside it (or convert it afterwards) to get native, replayable steps (excluding checks). QF-Test 11.1 removes several of these manual steps: bulk conversion of AI instructions into recordings, AI-controlled recording via MCP, and checks captured during recording. Broader support for AI reading and editing existing suites is still being investigated; until then, the underlying XML is your best option for small suites.

Interested in an early look at QF-Test 11.1? Contact us and let us know you’re interested!

Best practices for designing your own MCP toolkit with QF-Test

How to turn your own QF-Test procedures into a custom, self-documenting MCP toolkit for AI agents.

Max Melzer

25/09/2026

AI-driven test automation with QF-Test

With QF-Test 11, you can integrate your own AI models into agentic workflows and have them create and execute tests autonomously. Additionally, the integrated MCP-Server allows you to make the powerful QF-Test tools available to external agentic AI systems as well.

Best practices for designing your own MCP toolkit with QF-Test

2026-09-25T00:00:00+02:00

The new MCP server in QF-Test doesn’t just hand AI agents a generic, one-size-fits-all set of tools. You can also build your own procedures in QF-Test and expose them as purpose-built MCP tools, tailored to your application. We call this the MCP toolkit: your own QF-Test procedure library, turned into a bespoke, self-documenting, low-code toolset that any AI agent like Claude Code or Copilot can call directly.

This is a big innovation in QF-Test 11, and its usefulness goes well beyond test automation: Since QF-Test can drive almost any application (web, desktop, mobile, even PDF documents) your MCP toolkit can act as a bridge that makes a legacy application MCP-aware, letting an AI agent control it even though the application was never built with AI or MCP in mind.

In this post we’ve collected the best practices we discovered so far — for when a procedure deserves to become a tool, how to name and describe it, and how to fit it into QF-Test’s security model.

When to turn a procedure into an MCP tool

You can expose any QF-Test procedure as an MCP tool by adding the @mcp/tool doctag to its description field (or @mcp/tools to the enclosing package).

A custom MCP tool has one big advantage over the generic call_procedure tool: it’s self-documenting. The AI gets a dedicated name, parameter list, and description without ever needing to know the exact suite, procedure name or its arguments in advance.

That convenience has a cost, though: every registered tool takes up space in the AI’s context window. Register too many, and the AI has a harder time picking the right one. The actual limit depends on the AI model in use, but you should keep the set of enabled tools as small as you can.

That’s why building your MCP toolkit works best when you encapsulate large, multi-step business-logic actions (“Log in”, “Create new user”, “Place an order”) rather than exposing procedures that just wrap individual steps. Especially, you should not put “AI Instruction” nodes into your tools. This only introduces an extra layer of indirection and doesn’t give the AI anything it couldn’t already do itself.

You should also resist the temptation to expose your entire procedure library 1:1. Instead, create a dedicated suite of tool procedures that call into your library, or explicitly mark only the procedures that make good tools.

Granularity: higher-level beats low-level

In general, the higher-level your MCP tools are, the better. Every manual click, keystroke, or navigation step performed by an AI agent costs a comparatively large number of tokens, and the AI reasons through each one individually. QF-Test, on the other hand, executes sequences of clicks, keyboard input, and checks natively — much quicker and more reliably than even the best AI agent driving the UI step by step. A tool that wraps such a sequence lets the AI delegate the entire thing to QF-Test in a single call. This is is both dramatically faster and far more token-efficient.

What not to expose

Not every procedure makes a good tool. A few anti-patterns to watch out for when building your MCP toolkit:

Context-dependent procedures. If a tool only makes sense in a specific application state, the AI needs a way to detect that. Ideally an MCP tool always does something useful; at worst, it should fail with a helpful message that explains why it didn’t apply right now.
Long-running, stateful, or environment-dependent procedures need extra care in how they’re wrapped, since their behavior can be harder for the AI to predict and recover from. @mcp/timeout lets you adjust the timeout for tools. When the timeout ends, the underlying task will continue in the background until completion.
High-impact actions. AI models can make mistakes or be manipulated. Don’t expose tools that could cause unacceptable damage if misused. Keep destructive actions out of the toolkit, or gate them behind additional safeguards.

Writing tool descriptions the AI can actually use

When an LLM decides which tool to call, all it has to go on is the tool name, the parameter names (and any descriptions you provide), and the description drawn from the procedure’s comment. Put yourself in the AI’s shoes: it knows nothing about your application’s domain or terminology by default.

Here are some concrete suggestions to keep in mind:

Explain what the tool does, when to use it and what goals can be achieved by using it.
List valid or possible values for each parameter explicitly in its @param description. Also explain where to get possible input values from, if applicable.
Design the tool so it’s hard to use wrong in the first place. The less you have to explain, the fewer failure modes you have to guard against.
Keep descriptions short and to the point. Every word counts to the AI’s context budget.
End each tool procedure with a Return node which gives the AI feedback on the performed actions and the new state of the application.

The procedures shipped in our standard library qfs-ai.qft are a good reference for the level of detail that works well.

Naming tools: the `@mcp/name` doctag

MCP tool names have a hard limit of 64 characters. QF-Test derives a tool’s name from its package and procedure name and truncates automatically when needed.

If you’d rather not rely on automatic truncation, use the @mcp/name doctag to give a procedure or a package a short alias for MCP use, independent of how it’s named and organized internally.

Overriding the built-in AI tools

The general-purpose procedures shipped in qfs-ai.qft (under qfs.tools.ui) are meant to work reasonably well out of the box, but they can also serve as a blueprint for your own, more specific variants, for example if you want your “Open Browser” tool to launch with specific browser settings or your own CustomWebResolver instead of the defaults.

To override a built-in tool, provide a procedure with the same name in user-ai.qft; it will be used instead of the general-purpose one. (You can open the user-ai.qft suite in QF-Test via “File → Bookmarks → AI: User library”.) If you still want access to the original helper procedures from within your override, include ${qftest:version.dir}/include/qfs-ai.qft in your suite.

Internal vs. external tools, and permissions

QF-Test distinguishes between two ways a tool can be used:

External tools are called by external MCP clients connecting to the QF-Test MCP server.
Internal tools are used from within QF-Test itself — currently the “AI Instruction” node, the test generation wizard, and ai.askWithTools() in scripts.

In the QF-Test options dalog you can define for each tool individually whether it should be available for internal and/or external AI agents. The permission model differs between the two: QF-Test currently never asks for confirmation before running an internal tool, while external MCP clients generally ask for permission the first time a tool is used. Keep that in mind and be careful about which tools you enable internally.

You can use @mcp/exposedByDefault false so users need to explicitly enable the tool in the QF-Test settings, instead of automatically cluttering every users default context window.

Building your own MCP toolkit

The core idea behind all of these practices is the same: a well-curated MCP toolkit will make your AI agent both faster and more reliable than only handing it a large, generic set of low-level actions. Start small, apply @mcp/name and clear descriptions from the outset, and grow your toolkit as concrete use cases show you what’s worth wrapping.

For the full reference on the available doctags, see the “MCP Server” chapter of the QF-Test manual.

AI-driven test automation with QF-Test

A weekend together in Lichtenfels

2026-09-22T00:00:00+02:00

Last weekend, the QF-Test team and their families spent a weekend together in Lichtenfels.

At the traditional Korbmarkt, we strolled through colorful market stalls, sampled regional specialties, and soaked up the unique atmosphere of this historic basket-weaving town. Things got sporty at footgolf — with plenty of laughter and friendly competition, we enjoyed a wonderful afternoon against the stunning backdrop of the Obermain Valley’s iconic trio: the Basilica of Vierzehnheiligen, Banz Castle, and the Staffelberg.

Can I completely disable all AI features?

2026-09-21T00:00:00+02:00

Option 1 - Configuration

Don’t add an LLM, don’t enable the MCP server

Don’t create any entry in the “LLM Configurations” table and don’t check the “Enable embedded MCP server” option. Without a configured language model, QF-Test won’t make any AI requests.

Option 2 - System option

Enable the “Block AI features” option

The system option OPT_BLOCK_AI disables all functions that make LLM calls or provide AI interfaces in one go — regardless of any other settings.

Option 3 - Installation

Remove AI libraries

On Windows, AI features can be deselected during installation. On Linux and macOS, simply delete the files lib/langchain4j.jar and lib/mcp.jar from the installation directory.

All three options take permanent effect and can be combined — for example, in environments where a company policy prohibits the use of AI features entirely.

AI Test Automation with QF-Test

Who ya gonna call? Auto-generate procedure calls for clean and maintainable tests

2026-09-16T00:00:00+02:00

In this webinar, we’ll show you how QF-Test 11 can recognize matching procedures from your library while recording sequences and automatically insert the corresponding calls.

You can also use the same mechanism to clean up existing test cases automatically and replace individual nodes with structured procedure calls. The result is cleaner tests and consistent reuse.

Transcript

Daniel Rieth, QF-Test Software Developer
Ute Erler, QF-Test Software Developer and the person primarily responsible for the Procedure Recording feature

The Problem

When creating new tests, long sequences of mouse clicks, inputs, checks, and other QF-Test nodes are often created. At the same time, carefully designed procedures often already exist that take edge cases into account, ensure reliable test execution, and improve maintainability.

In a distributed team, however, there is no guarantee that test authors know about and use these existing procedures. Without support, this therefore results in test cases that reproduce the same logic again as individual nodes.

Procedure Call Recording solves this problem by automatically converting sequences of nodes into calls to existing procedures. This can be done both during recording and afterward through a conversion.

The key advantage is that the existing procedures are actually used. As a result, changes to the underlying functionality only need to be made in the procedure rather than in every individual test.

How It Works

The feature essentially consists of three components:

Procedure Call Definition

The Procedure Call Definition describes the characteristic actions of a procedure. It specifies which sequence of nodes should be recognized as a call to that procedure.

The definition is described using YAML notation and can be configured in detail. This makes it possible to specify which nodes are expected, the order in which they must occur, which of them are optional, and under what conditions a node is considered a match.

Conversion Function

The Conversion Function compares recorded or already existing sequences of nodes with the Procedure Call Definitions.

When a matching definition is found, QF-Test replaces the corresponding individual nodes with a call to the defined procedure. For example, a sequence of mouse clicks and inputs becomes a single procedure call with the corresponding parameters.

Recording Log

The Recording Log is particularly useful when creating and debugging Procedure Call Definitions. It shows which expected nodes were recognized and at which point a definition no longer matches the actual recording.

This makes it possible to understand why a definition did not match and what adjustment is required.

Automatically Recognizing Simple Procedures

As an initial demonstration, an application for calculating property tax is used. It already contains procedures for opening and canceling the dialog for creating a business.

A normal recording would only contain the corresponding mouse clicks. However, using More Node Operations → Record Nodes Again as Procedure Calls, these nodes can subsequently be converted into calls to the existing procedures.

The corresponding Procedure Call Definitions can be generated directly from the existing procedures. For short and unambiguous procedures, this automatic generation often works without any further adjustments.

The demonstration also shows that procedure calls can already be created during recording. To do this, Procedure Call Recording is enabled. The recorded actions are then immediately checked against the existing Procedure Call Definitions.

Procedure Call Definitions and the Recording Log

An automatically generated definition describes, among other things:

the associated procedure,
its priority,
the expected order of the nodes,
the expected components and events,
optional nodes, and
procedure parameters, where applicable.

A simple definition can, for example, expect a mouse click on a specific button.

More complex procedures can also be described. For example, if a button for discarding changes is optionally displayed after clicking a Cancel button, this second step can be defined as optional.

The Recording Log makes it visible how this definition is processed: first, the expected Cancel button must be found; afterward, the optional click on the button for discarding the changes can follow.

More Complex Definitions with Conditions and Placeholders

Not every automatically generated definition is immediately robust enough. A procedure for changing the language serves as an example.

The UI contains two possible toggle buttons, one for German and one for English. The automatic generation initially recognizes these as possible alternatives and represents them as a Choice Group.

The demo shows, however, that the components actually used do not exactly match the automatically generated definitions. One reason is that the component’s ID changes depending on the current state.

The definition can therefore be refined. Instead of using only the ID, for example, the Class of the component can be used. This allows the definition to initially recognize a Toggle Button in a more general way.

For an even more precise distinction, Conditions can be used. A Condition can, for example, check whether the ID of a component begins with specific text.

Placeholders are used for this purpose. During recording, they provide concrete properties of the node currently being processed, such as the ID of a component. These values can be compared within a Condition or output as procedure parameters.

This allows a definition to distinguish, for example, whether the German or English Toggle Button was used and accordingly generate de or en as the procedure parameter.

Automatically Recording Procedure Parameters

Procedure Call Definitions can not only recognize that a procedure was used; they can also take over the parameters used during recording.

For this purpose, the Set Procedure Call Parameter node is used. Recorded values can thus be automatically extracted from text or selection actions and passed on as parameters of the procedure call.

This makes it possible, for example, to derive a language parameter from the component that was actually clicked.

The Different Groups

Expected nodes are organized into groups. Three groups are particularly relevant.

Sequential Group

A Sequential Group expects its nodes in a specific order.

For example, a definition can expect:

a mouse click,
a text input, and
a check afterward.

The order is relevant. Repetitions can be defined for individual nodes. A node can also be marked as optional.

An optional node essentially corresponds to a Repeat section that also permits zero occurrences.

Choice Group

A Choice Group describes several possible alternatives. It is expected that one of the contained nodes or branches will occur.

This is suitable, for example, for if/else behavior. In the language-changing procedure, either the German or the English Toggle Button can be selected.

Choice Groups can also contain repetitions and optional content.

Unsorted Group

An Unsorted Group is suitable for multiple nodes whose order does not matter.

A typical example is a form in which several text fields are filled in. For matching, it may be relevant that certain inputs occurred, while the order of those inputs should not be fixed.

For individual nodes within a Sequential Group, a Repeat can alternatively be used. An Unsorted Group is particularly useful when several different nodes should be recognized independently of their order.

Complex Procedure: “New Winery”

A more extensive demonstration uses the New Winery procedure. It performs several actions:

entering data into various text fields,
selecting a federal state,
selecting a viticultural use,
interacting with a table,
entering a property-tax assessment rate,
optionally opening the calculation scheme, and
saving the new entry.

The automatically generated Procedure Call Definition does not initially work completely. The example shows how such a definition can be made more robust step by step.

Excluding Mouse Events from the Recording

A problem arises because a user may first click into a text field before entering text. However, the actual procedure does not require this mouse click.

Instead of adding an optional mouse click to the definition for every individual text field, an Ignore Definition can be used.

Since QF-Test 11.0.2, the following option can be used directly:

Ignore the following nodes for procedure call recording

This can be used, for example, to exclude Mouse Events on text fields from Procedure Call Recording. Specific clicks on a table can also be ignored in this way.

As a result, the definition is independent of whether the user initially clicks into a field or navigates there using the keyboard, for example.

Ignoring Keyboard Events

The same principle can be applied to keyboard events. During manual input, for example, Tab, Enter, Backspace, or other keys may occur between the actual relevant actions.

Such events can be excluded using an Ignore Definition. A Condition can check the <Keycode> of the event and ignore specific keycodes.

This keeps the Procedure Call Definition focused on the actions that are relevant from a functional perspective, rather than making it dependent on the specific interactions of the test author.

Combining Multiple Text Inputs

A single logical text input can also consist of multiple Text Input Events during recording. This can happen, for example, when a user enters part of a text, deletes it, and then corrects it.

One option is to define a Repeat for the corresponding node. If several different nodes can occur independently of one another, an Unsorted Group is more suitable.

When generating procedure parameters, multiple consecutive inputs can also be combined. If, for example, the values are concatenated without a separator, multiple recorded Text Inputs can once again produce the original parameter value.

Describing Nodes in Detail

The expected nodes can be described more precisely using numerous properties.

For a mouse click, for example, properties of the event can be taken into account. Components can be identified using, among other things, the following characteristics:

ID,
Class,
other component attributes, and
Conditions.

Key Events can also be described using their keycode.

In addition, repetitions, optional nodes, and procedure parameters can be specified for individual definition elements.

The YAML definition can be edited directly. The corresponding editing function helps ensure that the required structure and indentation are maintained correctly.

Using the Recording Log for Debugging

The Recording Log is not only relevant for actual recordings. It can also be used when subsequently converting existing sequences of nodes.

If a Procedure Call Definition does not match, the log can be used to trace step by step which expected node was not recognized.

The basic approach is to follow the definition in the log until reaching the point where the actual recording deviates from the expected structure. The definition can then be adjusted, for example, by using a different component description, a Condition, a Repeat, or an optional node.

Automatic Procedure Parameters for Complex Recordings

Parameters can also be automatically taken from the recording for longer procedures.

In the New Winery example, the business name, ownership area, and assessment rate, among other values, are taken from the corresponding inputs. Procedure Call Recording automatically creates these as parameters of the subsequent procedure call.

This means that the test author does not have to manually enter the parameters into the generated procedure call afterward.

Outlook

The Procedure Call feature is intended to be expanded further. Two planned or currently developing integrations are particularly highlighted.

Integration with Keyword Driven Testing

Procedure Call Recording is intended to be integrated with Keyword Driven Testing.

This will allow procedure calls to be displayed in a form that is easier for business departments to understand. Instead of displaying merely a procedure path with parameters, the test can, for example, be represented as freely formulated text or as a keyword-based action.

The feature is particularly interesting for users who want to formulate tests more strongly at the business level. A beta version is already being used by customers.

Integration with AI

QF-Test’s AI functions are also intended to be connected with Procedure Call Recording.

QF-Test can already generate tests using AI and use an AI Instruction Node to execute actions with the UI. The goal is for such automatically generated actions to be mapped directly to existing procedures.

This is intended to apply both to AI-generated test sets and to the recording of actions executed within an AI Instruction Node.

Conclusion

Well-designed and robust Procedure Call Definitions help ensure that existing procedures are actually used in tests.

Procedure Call Recording can be used both during recording and subsequently during conversion.

Procedure Call Definitions can be generated automatically from existing procedures and then refined as needed. For more complex cases, the following mechanisms are available, among others:

Sequential Groups,
Choice Groups,
Unsorted Groups,
Conditions,
Placeholders,
optional nodes,
Repeat sections,
Ignore Definitions, and
automatic procedure parameters.

For more complex procedures, a certain amount of familiarity with the definition language is required. However, the available mechanisms make it possible to specify very precisely which recordings should be recognized as calls to a particular procedure.

How to run the QF-Test license server as a Windows service

2026-09-14T00:00:00+02:00

QF-Test offers floating licenses to give you maximum flexibility at a low cost, but these are limited to sub-networks. That is why we provide the QF-Test license server: it enables centralized license management across subnet boundaries – even across different time zones – so your teams can work seamlessly wherever they are.

We strongly recommend running the QF-Test license server as a Windows service. This ensures predictable startup, resilience after reboots, and simple operations for both technical and non-technical stakeholders.

What is a license server and why does it matter for test automation?

A license server manages shared licenses for software like QF-Test, enabling multiple users and systems to use the product without installing separate licenses on every machine. For test automation teams, this central control ensures:

Efficient use of concurrent licenses across QA engineers and CI systems
Visibility and control for administrators
Reduced friction for testers and developers who just need to run their tests

Why run the QF-Test license server as a Windows service?

Running the QF-Test license server as a Windows service helps your Windows administration team ensure that the service starts automatically with the operating system, recovers after reboots, and can be monitored and controlled via standard Microsoft Windows tools:

Automatic start and restart: Ensures the service is always available after a reboot or patch cycle.
Standardized operations: Start, stop, and monitor via the Windows Services console (services.msc).
Centralized logging: Find logs in one place for troubleshooting and auditing.
Consistent behavior for CI/CD and distributed test automation.

Before you start: Prerequisites

Administrator (elevated) rights on the Windows machine that will host the QF-Test license server
Network access for clients to reach the license server

Prepare the QF-Test license server

Install QF-Test using the official installer. Beyond the files in C:\Program Files\QFS, the installer creates the folder %PROGRAMDATA%\QFS\QF-Test and configures the required access rights for license server administration.
Open the folder %PROGRAMDATA%\QFS\QF-Test in Windows Explorer. Because %PROGRAMDATA% is typically hidden, paste %PROGRAMDATA%\QFS\QF-Test into the Explorer address bar.
Copy the following license files into that folder:
- license (client license file, no extension like .dat or .txt)
- license.server (server license file)
Verify access rights: The files and folder must grant read/write permissions to users who will administer the QF-Test license server. If you used the installer, these rights should already be inherited. If not, set them manually.

Set a secure password for the QF-Test license server

Setting a password is essential for two reasons:

Security: Do not rely on the default password (“secret”).
Initialization: Explicitly setting the password creates the passwd file used by the license server.

In %PROGRAMDATA%\QFS\QF-Test, open the Windows Terminal (PowerShell) by right-clicking in the Explorer window’s white area and selecting the terminal option.
After opening the Terminal, a PowerShell prompt appears.
Run the following command (PowerShell syntax), replacing your_password with a strong password:

qftestc --userdir="$env:ProgramData\QFS\QF-Test" -batch -licenseserver -licenseserverSetpwd admin=your_password

After a few seconds, you should see a confirmation and the passwd file should appear in the folder. If the command fails, it is most likely due to insufficient permissions for %PROGRAMDATA%\QFS\QF-Test.

Install the QF-Test license server as a Windows service (`winsw`)

The QF-Test license server is not a native Windows service. To run it as one, you use a service wrapper. The approach described here uses winsw (a third-party Windows service wrapper). If your organization prefers a different wrapper, you can adapt the configuration accordingly. Capabilities vary by wrapper tool.

We are not the authors of winsw. If there are any issues with this tool, we cannot provide support beyond this documentation. For details about winsw, visit its GitHub page.

Download the prepared Service wrapper package qftest-license-service.zip.
Copy qftest-license-service.zip to %PROGRAMDATA%\QFS\QF-Test and extract it. This creates a service subfolder: %PROGRAMDATA%\QFS\QF-Test\service.
Open PowerShell and change into the “service” folder:
- Set-Location service
- or: cd service
The folder contains a preconfigured winsw setup:
- QF-TestLicenseServer.NET4.xml (winsw configuration)
- QF-TestLicenseServer.NET4.exe (winsw.exe renamed for clarity)
- installService.ps1 (PowerShell script to install the service)
Run the script: .\installService.ps1

If you see an error that script execution is disabled, bypass it for this command only: PowerShell -ExecutionPolicy Bypass .\installService.ps1

If your company policy blocks execution policy overrides, ask your administrator to enable third-party PowerShell scripts for your user or machine.
During installation:
- A Windows UAC prompt should request admin approval. Click “Yes”.
- A cmd.exe window may appear during the process.
- After completion: You should see a confirmation that the QF-Test license server is installed as a Windows service.

Verify, operate, and maintain the service

Verify: Open the Windows Services console (services.msc) and look for “QF-Test License Server”. Use the context menu to start, stop, or restart the service.
Logs: %PROGRAMDATA%\QFS\QF-Test\log
Additional scripts: %PROGRAMDATA%\QFS\QF-Test includes PowerShell scripts to start, stop, or uninstall the service.
Firewall: On first use of QF-Test, you may see a Windows Firewall dialog asking to allow the Java runtime (installed with QF-Test) to access your network. Allow this so clients can connect to your QF-Test license server.
Documentation: For advanced administration, consult the QF-Test license server manual

Troubleshooting tips for Microsoft Windows environments

No UAC prompt appears

Your system may enforce stricter User Account Control settings. Contact your administrator to proceed with service installation.

“Script execution is disabled”

Use PowerShell -ExecutionPolicy Bypass .\installService.ps1 for a one-off run. If this is blocked by policy, ask your administrator to enable third-party PowerShell scripts for your user or machine.

Cannot set or change the password

Check permissions on %PROGRAMDATA%\QFS\QF-Test and ensure your account has read/write access.

Service starts before networking is available

The winsw configuration includes basic dependency handling so the service only starts when a network is attached. If using another wrapper, ensure equivalent behavior.

I prefer a different service wrapper

You can replace winsw with a wrapper of your choice. Adapt the configuration accordingly and ensure start/restart/stop and network dependency handling are covered.

Practical checklist for QF-Test in Windows-based test automation

Install QF-Test via the official installer to preconfigure %PROGRAMDATA%\QFS\QF-Test with correct permissions.
Place license and license.server into %PROGRAMDATA%\QFS\QF-Test.
Set the admin password using qftestc and confirm the passwd file is created.
Download and extract qftest-license-service.zip to create the “service” subfolder and run installService.ps1.
Approve the UAC prompt, then verify the “QF-Test License Server” in services.msc.
Allow the Windows Firewall prompt for the Java runtime bundled with QF-Test.
Use %PROGRAMDATA%\QFS\QF-Test\log for diagnostics and the included PowerShell scripts for service lifecycle tasks.

QF-Test 11.0.2 available

2026-09-09T00:00:00+02:00

QF-Test 11.0.2 is primarily a security release, lifting the integrated JRE to Temurin OpenJDK 25.0.4.1 along with updates of Groovy, langchain4j, mcp, cdp4j, undertow and others. It also adds support for Eclipse/SWT 4.41 alias “2026-09” and improves MCP integration with a new tools overview page accessible from the options dialog. Procedure call recording has been enhanced in several ways.

QF-Test special webinar on September 14, 2026 & security release QF-Test 11.0.2

2026-09-09T00:00:00+02:00

Hello dear QF-Test users!

Our next QF-Test Special Webinar is just around the corner – September 14, 2026:

👻 Who ya gonna call? Auto-generate procedure calls for clean and maintainable tests

Messy test cases haunting your code? Duplicate nodes lurking around every corner? QF-Test 11 is on the case. 🔦 No proton pack required. Just the brand new QF-Test 11.0.2 release. Register for free.

Good tests need a solid foundation: QF-Test 11.0.2 is primarily a security release, lifting the integrated JRE to Temurin OpenJDK 25.0.4.1. It also adds support for Eclipse/SWT 4.41 alias “2026-09” and enhances procedure call recording in several ways. Update recommended!

Best regards,

your QFS team

Next QF-Test special webinar

September 14, 2026, 3:30 PM (CEST) Who ya gonna call? Auto-generate procedure calls for clean and maintainable tests

In this webinar, we’ll show you how QF-Test 11 can recognize matching procedures from your library while recording sequences and automatically insert the corresponding calls. You can also use the same mechanism to clean up existing test cases automatically and replace individual nodes with structured procedure calls. The result is cleaner tests and consistent reuse.

Alternative date: Webinar in German on September 14, 2026, at 10:30 AM

Download QF-Test

Are you already using the latest version of QF-Test?

Download QF-Test 11.0.2

To the Release Notes
Watch the Release video
Available since 2026-09-09

Events in 2026

Quality is NOW – Networking Around Quality Engineering, Leipzig, September 15, 2026

QF-Test is sponsoring the German Testing Board meetup on the eve of Tacon in Leipzig – featuring a keynote by Lilia Gargouri (Head of QA | mgm technology partners), a World Café session, and discussions on AI and test automation. Admission is free, but space is limited – register now!

➜ To the meetup

QF-Test Basics: training courses via webinar

➡️ September 21–24, 2026 in German

📆 October 5-8, 2026 in English

More about the training courses

4 days, 2 × 2.5 hours each
Effective and rapid knowledge transfer
Small groups up to 8 participants
You can interact with the trainers and ask questions at any time.

Individual QF-Test company trainings

Would you like a training course which is individually tailored to your company? Just send us an email to service@qftest.com.

Ask our service team for a quote

QS-Tag November 11-12, 2026

QF-Test will be represented at the QS-Tag in Frankfurt am Main with both a booth and a talk. Thomas Max, Senior Software Engineer and Advanced Trainer at QF-Test, will demonstrate how AI agents use MCP to autonomously explore even legacy systems and generate reusable test cases from them – including an honest look at security issues such as prompt injection. Feel free to stop by.

➜ To QS-Tag

From our YouTube Channel

AI agents in action: autonomous test generation and MCP with QF-Test 11

In the recording of our webinar, we’ll show how QF-Test 11 integrates AI directly into your everyday testing workflow. From AI instructions in individual test steps to automatically generating comprehensive test cases.

➜ Watch the video now

Visit our YouTube channel to subscribe and follow us on LinkedIn.

AI agents in action: autonomous test generation and MCP with QF-Test 11

2026-08-17T00:00:00+02:00

We’ll also demonstrate how to connect QF-Test to external AI agents like Claude Code or GitHub Copilot via the new MCP server, making any application ready for agentic workflows.

Materialien

Summary

AI in QF-Test

QF-Test supports test data generation, test suite generation, and AI instructions, among other things. The approach follows the Bring Your Own Model principle: companies can choose which AI model they want to use. This allows them, for example, to retain control over their data by using internal or self-hosted models. Costs can also be adjusted by choosing the appropriate model.

Connecting AI models

The talk begins by setting up AI support in QF-Test. CLI tools can also be integrated, with many configuration values being determined automatically.

AI test data generation

AI data generation provides a first simple way to verify that the AI configuration is working. QF-Test generates test data, such as a table, based on both a user prompt and a predefined system prompt.

The prompts used for generation can be inspected and customized. For example, the user can specify that generated data should be French wherever possible.

AI suite generation

AI suite generation creates a test design from a natural-language description. The user’s prompt is combined with a predefined system prompt.

As an example, the AI is asked to generate tests for a Swing application:

Generate tests to test the functionality of the 5% discount button. Stay in the “Vehicles” tab and don’t open any dialogs via the menu.

QF-Test generates, among other things, a test description and a test plan. Wherever possible, generated steps should be converted into regular QF-Test nodes, with AI optionally serving as a fallback.

AI instructions

AI instructions allow QF-Test to perform tasks during test execution using natural language, for example:

Open the application’s Info dialog.

These instructions make use of internal MCP tools. The execution and the tools used can be inspected in the QF-Test log.

QF-Test as a tool for AI: MCP

The second major topic is the reverse direction: not only can QF-Test use AI, AI applications can also access QF-Test functionality.

QF-Test exposes capabilities such as component recognition and UI control through MCP (Model Context Protocol). QF-Test effectively provides a toolkit for defining custom MCP tools for virtually any application and making those tools available to an AI.

Example: Chess

A simple chess application demonstrates how QF-Test and AI can be combined. The chessboard itself has no game logic, but QF-Test can move the pieces.

First, the AI is allowed to play several moves. The current position can then be sent to an external API, which calculates the next move. QF-Test receives the result and executes the move. While this works, directly controlling the game through AI can be relatively token-intensive.

The next step is to expose existing QF-Test procedures as MCP tools. Functions for moving a piece, calculating the next move, starting the chess application, and resetting the board are turned into explicitly described tools.

This allows an external AI to call these functions directly and decide, for example, when to calculate a new move or move a piece.

Defining custom MCP tools

Custom tools can be defined directly in QF-Test. Procedures are annotated with MCP-specific metadata and documented with descriptions, parameters, and return values.

The resulting MCP suite can then be integrated into QF-Test. An AI application such as Claude can access the tools through the MCP server and use them during a conversation.

Example: Windows Calculator

Finally, the concept is applied to a different application. A normal QF-Test sequence is first recorded for the Windows Calculator:

Enter a number
Press plus
Enter a second number
Press equals
Read the result

This functionality is then exposed as an MCP tool. An AI can use the QF-Test calculator tool, for example, to add two single-digit numbers and return the result.

An intentionally incorrect expected result can then be used to demonstrate how QF-Test detects and logs the resulting error.

The MCP server can be operated not only interactively, but also in batch mode.

Conclusion

QF-Test 11 connects AI and automated testing in both directions: AI can assist within QF-Test with generating test data, test suites, and test steps. At the same time, QF-Test can expose its capabilities through MCP as a set of tools for external AI applications.

This makes it possible to use existing QF-Test functionality to enable AI-driven interaction with virtually any application.

QF-Test 11.0.1 available

2026-08-13T00:00:00+02:00

QF-Test 11.0.1 improves on the AI and recording features introduced in QF-Test 11.0. It includes security updates, lifts the integrated JRE to Temurin OpenJDK 25.0.4, and adds support for Electron 43. Checks on list items are now also supported on Android and iOS.

QF-Test 11.0.1 and special webinar on August 17, 2026, regarding AI agents and MCP

2026-08-13T00:00:00+02:00

Hello dear QF-Test users!

Test automation is going through a real transformation – and QF-Test is right at the heart of it. With Version 11, we’ve woven AI directly into your everyday testing workflow: from smart AI instructions in individual test steps to the automatic generation of entire test cases. And with the new MCP server, we’re opening QF-Test up to the world of AI agents – whether that’s Claude Code, GitHub Copilot, or other tools.

Want to see it in action? Join us live at our special webinar on August 17, 2026 – free to attend and hands-on from the start.

We’ve also just released QF-Test 11.0.1, a maintenance release packed with a handful of helpful improvements.

By the way, our next QF-Test basic training is taking place in September – and there are still spots available!Best regards,
your QF-Test team

Next QF-Test special webinar

August 17, 2026, 3:30 PM (CEST) AI Agents in action: autonomous test generation and MCP with QF-Test 11

In this webinar, we’ll show you how QF-Test 11 integrates AI directly into your everyday testing workflow: from AI instructions in individual test steps to automatically generating comprehensive test cases. We’ll also demonstrate how to connect QF-Test to external AI agents like Claude Code or GitHub Copilot via the new MCP server, making any application ready for agentic workflows.

Alternative date: Webinar in German on August 17, 2026, at 10:30 AM

Download QF-Test

Are you already using the latest version of QF-Test?

Download QF-Test 11.0.1

To the Release Notes
Watch the Release Video
Available from 2026-08-12

Events in 2026

Quality is NOW – Networking Around Quality Engineering, Leipzig, September 15, 2026

QF-Test Basics: training courses via webinar

📆 September 21–24, 2026 in German

📆 October 5–8, 2026 in English

More about the training courses

4 days, 2 × 2.5 hours each
Effective and rapid knowledge transfer
Small groups up to 8 participants
You can interact with the trainers and ask questions at any time.

Individual QF-Test company trainings

Would you like a training course that is individually tailored to your company? Just send us an email to service@qftest.com.

Ask our service team for a quote

QS-Tag November 11-12, 2026

From our YouTube channel

Release video QF-Test 11

In this video, we’ll show you how QF-Test 11 takes your test automation to the next level with powerful AI features.
➜ Watch the video now

Visit our YouTube channel to subscribe and follow us on LinkedIn.

AI agents in action – autonomous test generation and MCP with QF-Test 11

2026-08-12T00:00:00+02:00

We are pleased to invite you to our next free special webinar:

“AI agents in action – autonomous test generation and MCP with QF-Test 11”

Monday, August 17, 2026, 3:30 PM – 4:30 PM CEST

In this webinar, we’ll show you how QF-Test 11 integrates AI directly into your everyday testing workflow. From AI instructions in individual test steps to automatically generating comprehensive test cases. We’ll also demonstrate how to connect QF-Test to external AI agents like Claude Code or GitHub Copilot via the new MCP server, making any application ready for agentic workflows.

QF-Test 11 available

2026-07-29T00:00:00+02:00

AI can fundamentally speed up and streamline test automation workflows. That’s why QF-Test 11 focuses on AI – with full control over which models have access to your data.

With this version, you can generate test cases using AI assistance, embed AI instructions directly into test runs, and make your applications MCP-ready.

This release also introduces powerful new features, such as the new function for recording procedure calls, for more robust, efficient, and enjoyable software quality assurance with QF-Test. You can find more details in this newsletter.

QF-Test 11 now available: Generate test cases with AI – securely and efficiently

2026-07-29T00:00:00+02:00

Hello dear QF-Test users!

AI can fundamentally speed up and streamline test automation workflows. That’s why QF-Test 11 focuses on AI – with full control over which models have access to your data.

With this version, you can generate test cases using AI assistance, embed AI instructions directly into test runs, and make your applications MCP-ready.

This release also introduces powerful new features, such as the new function for recording procedure calls, for more robust, efficient, and enjoyable software quality assurance with QF-Test.

We hope you enjoy exploring everything that’s new!

Best regards,
your QF-Test team

Download QF-Test

Are you already using the latest version of QF-Test?

QF-Test 11.0 is a major release with many new features. QF-Test now acts as an MCP server, giving AI agents access to all applications QF-Test can control.

A new AI assistant generates test cases from live application analysis.

OpenAPI specifications can be imported to automatically create comprehensive test suites with CRUD tests and procedure libraries, for REST APIs.

With a new recording feature, interactions can now automatically be replaced with matching procedure calls, and a command palette provides instant keyboard access to all QF-Test functions.

Download QF-Test 11

To the Release Notes
Available from 2026-07-29

In the release video, we’ll show you how to bring your test automation into the AI era with QF-Test 11, and walk you through new features for more stable, efficient, and enjoyable software quality assurance with QF-Test.

➜ Watch the video now

Highlights QF-Test 11

AI features

Test case generation with AI at the click of a button

Simply describe what you want to test – the built-in AI agent inspects your application live and delivers a ready-to-run test case draft within minutes, which you can then refine and build on directly in QF-Test.

AI instruction nodes

Tell the AI in plain language what it should do or verify – it executes your instruction dynamically and reliably via the QF-Test connection.

Test data generation

Tailored test data at the click of a button: QF-Test generates matching data tables directly in your test project – so you can hit the ground running with your own tests.

Claude Code & GitHub Copilot

The popular command-line tools are now officially compatible – QF-Test stays true to its open “bring your own model” approach and continues to grow.

MCP server & MCP toolkit

Control QF-Test directly from your terminal or IDE – and make previously non-AI-ready applications MCP-ready. This allows robust UI tests for websites, applications, and apps to be seamlessly integrated into agentic development environments.

More highlights from QF-Test 11

Recording procedure calls or converting them after the fact

When recording sequences, QF-Test automatically detects matching procedures from your library and inserts the corresponding calls. You can also use the same mechanism to clean up existing test cases automatically, replacing individual nodes with structured procedure calls. This keeps your tests clean and ensures consistent reuse.

Web API: OpenAPI import

Import an OpenAPI specification (formerly “Swagger”) and get a complete test suite in seconds that automatically covers every endpoint including CRUD sequences and parameters – ensuring at all times that your API behaves exactly as specified.

Fast navigation

With the new command palette, a keyboard shortcut in QF-Test 11 gives you instant access to every feature as well as all elements in your test suites and projects. The smart search algorithm handles fuzzy search terms with ease.

There are many more features to explore in QF-Test 11, such as the Android recording window with live preview and the group variables in the debugger. You can find all the details in the Release Notes on our website.

Events in 2026

Next QF-Test special webinars

August 17, 2026, 3:30 PM (CEST) AI Agents in action: autonomous test generation and MCP with QF-Test 11

Alternative date: Webinar in German on August 17, 2026, at 10:30 AM

September 14, 2026, 3:30 PM (CEST) Who ya gonna call? Auto-generate procedure calls for clean and maintainable tests

Alternative date: Webinar in German on September 14, 2026, at 10:30 AM

QF-Test Basics: training courses via webinar

📆September 21–24, 2026 in German

📆October 5–8, 2026 in English

More about the training courses

4 days, 2 × 2.5 hours each
Effective and rapid knowledge transfer
Small groups up to 8 participants
You can interact with the trainers and ask questions at any time.

Individual QF-Test company trainings

Would you like a training course which is individually tailored to your company? Just send us an email to service@qftest.com.

Ask our service team for a quote

From our YouTube Channel

Get X-Ray vision: integrate QF-Test results with Q12-TMT and Xray

Q12-TMT and Xray Test Management are popular test management tools. In this special webinar, we’ll show you how to use the latest features in QF-Test to sync your test results with Q12-TMT and Xray – combining QF-Test’s detailed reports with the strengths of these tools.

➜ Watch the video now

Visit our YouTube channel to subscribe and follow us on LinkedIn.

QF-Test Version 11

2026-07-29T00:00:00+02:00

Pressing the play button will load a video from our external provider YouTube. Privacy Policy

KI-Features

Test case generation with AI at the click of a button Simply describe what you want to test – the built-in AI agent inspects your application live and delivers a ready-to-run test case draft within minutes, which you can then refine and build on directly in QF-Test.

AI instruction nodes Tell the AI in plain language what it should do or verify – it executes your instruction dynamically and reliably via the QF-Test connection.

Test data generation Tailored test data at the click of a button: QF-Test generates matching data tables directly in your test project – so you can hit the ground running with your own tests.

Claude Code & GitHub Copilot The popular command-line tools are now officially compatible – QF-Test stays true to its open “bring your own model” approach and continues to grow.

MCP server & MCP toolkit Control QF-Test directly from your terminal or IDE – and make previously non-AI-ready applications MCP-ready. This allows robust UI tests for websites, applications, and apps to be seamlessly integrated into agentic development environments.

More highlights from QF-Test 11

Recording procedure calls or converting them after the fact When recording sequences, QF-Test automatically detects matching procedures from your library and inserts the corresponding calls. You can also use the same mechanism to clean up existing test cases automatically, replacing individual nodes with structured procedure calls. This keeps your tests clean and ensures consistent reuse.

Web API: OpenAPI import Import an OpenAPI specification (formerly Swagger) and get a complete test suite in seconds that automatically covers every endpoint including CRUD sequences and parameters – ensuring at all times that your API behaves exactly as specified.

Fast navigation With the new command palette, a keyboard shortcut in QF-Test 11 gives you instant access to every feature as well as all elements in your test suites and projects. The smart search algorithm handles fuzzy search terms with ease.

There are many more features to explore in QF-Test 11, such as the Android recording window with live preview and the group variables in the debugger.

Detailed Release Notes QF-Test Version 11

QF-Test Version 11.0.1

2026-08-13

QF-Test Version 11.0.2

2026-09-09

QF-Test 11 – Agentic AI features and more

2026-07-28T00:00:00+02:00

Hello! My name is Daniel and today I’ll show you how to bring your test automation into the AI era with QF-Test 11.

I’ll also walk you through additional features of our new version of QF-Test.

1. AI

QF-Test is our extremely powerful tool for professional UI test automation. It supports testing of many different software platforms, offers a sophisticated visual UI for editing and debugging tests, and countless other useful features.

Yet for months, conversations have been dominated by one topic: How do you handle Artificial Intelligence? And rightly so: AI is very capable of accelerating and streamlining processes in test automation.

That is why the focus of QF-Test 11 is on our AI capabilities.

QF-Test 11 integrates AI in two dimensions:

AI features IN QF-Test:

Generate tests exploratively or from documentation
Integrate AI instructions and decisions into tests

AI features WITH QF-Test:

Control QF-Test (and third-party applications) with AI agents
MCP toolkit: Make any application AI-ready
I’ll now give you a brief overview of these new functions.

1.1 Test case generation When you launch QF-Test, a brand-new icon greets you in the toolbar: our test suite generation assistant. Simply tell it what you want to test, and QF-Test works with an integrated AI agent to turn your plan into a well-structured, functional test suite draft. The QF-Test agent can examine your application live and independently identify the most important functions and paths for a thorough test – within just a few minutes you receive a detailed test case draft that you can continue working on in QF-Test.

1.2 AI Instructions At the heart of these generated test steps is the new “AI Instruction” node, which makes the extensive capabilities of an AI available during your test run. Tell the AI what it should do or verify, and the selected AI model will use the robust connection between QF-Test and your application to execute your instructions efficiently and dynamically.

1.3 Data Table Generation AI also supports you in other areas of QF-Test. For example, you can now generate tailored test data in data tables with just a few clicks to speed up the testing process.

1.4 Native Support for Claude Code and GitHub Copilot As before, QF-Test follows an open “bring your own model” approach for AI: you can simply configure your own AI models via the options and then use them flexibly within QF-Test.

With QF-Test, you always remain in control and can decide for yourself which AI provider and which model is granted access to your test data. We also ensure that smaller models can work well with QF-Test’s tools. The list of compatible providers is constantly growing and now includes the popular command-line tools Claude Code and GitHub Copilot.

1.5 MCP and MCP Toolkit But we also know that power users have long been working with agentic AI, in their own terminal or IDE. QF-Test can be used there too, thanks to the new built-in MCP server. Our MCP server provides efficient and powerful tools to enable your AI agent to control and test websites, applications, and apps. This lets you integrate robust UI tests directly into your existing agentic development environment.

But QF-Test 11 goes one step further: thanks to our MCP toolkit, you can extend the list of tools as you see fit. Simply record a sequence of steps with QF-Test, convert it into a procedure, and activate it as an MCP tool. This lets you use QF-Test as a kind of proxy to make applications MCP-capable that were previously not controllable by AI.

We’re excited to see what new process automation possibilities our users will unlock with the MCP toolkit.

But enough about AI – the core mission of QF-Test remains robust, stable, and reproducible UI test automation. QF-Test 11 also delivers great new features in this area.

2. Automatic Procedure Recording

The new procedure recording feature makes it possible to identify suitable procedures from your own procedure library during the interactive recording of actions and automatically insert them into your test. This makes it easier for you and your team to find and consistently use your own procedures. You can also use the same mechanism to automatically clean up existing test cases and replace individual nodes with structured procedure calls.

The configuration of this automatic procedure detection is extremely flexible and well documented, making it suitable for complex procedures and libraries as well.

3. OpenAPI Import

Also new in QF-Test is the OpenAPI import. OpenAPI is an industry standard for specifying web API interfaces. With QF-Test 11, you can import such specifications into QF-Test – QF-Test then creates a comprehensive test suite in seconds that can test every single endpoint and parameter for correct behavior. This ensures at any point in time that your API actually behaves in accordance with its specification.

When the importer can detect a Create/Read/Update/Delete operation group for a resource, it generates a self-contained test case that:

Declares all necessary variables within the test case – the path parameter, all required header parameters, and body fields with representative test values.

Links the complete CRUD sequence: CREATE (captures the primary key), READ (verifies the created values), UPDATE (modifies values), VERIFY UPDATE (fetches again and verifies), DELETE (removes the resource).

Each phase is introduced by a comment node for better readability.

4. Command Palette

Using QF-Test is made enormously easier in QF-Test 11 by the new command palette. You can call it up at any time using a simple keyboard shortcut and search through your suites and projects. (Show shortcut) You can also find and use almost any function of QF-Test through the palette. The underlying search algorithm is intelligent and handles fuzzy search terms without any difficulty.

In summary:

QF-Test 11 brings powerful AI tools for test generation and execution, as well as an MCP server.

The innovative MCP toolkit also makes it possible to integrate previously non-AI-capable applications into agentic workflows.

And on top of that, QF-Test 11 offers, as always, excellent cross-platform software quality assurance and numerous small and large quality-of-life improvements.

As always, everything new in QF-Test 11 can be found in the detailed release notes on our website qftest.com. There you will of course also find the download link for a free trial version, so you can get started with QF-Test 11 right away.

How does the AI agent interact with the SUT? Can I track which actions the AI performs?

2026-07-15T00:00:00+02:00

The AI can interact with the SUT using MCP tools provided by QF-Test. It uses the same component recognition and simulates user interactions in the same way.

When using AI in QF-Test, all actions, MCP tool uses, and responses from the AI agent are documented in the log. This enables full traceability of what the agent did and how it arrived at its results.

AI Test Automation with QF-Test

Depth limits, accidental data deletion, irreversible actions: How do I restrict AI during autonomous exploration of an SUT for test generation?

2026-07-15T00:00:00+02:00

Autonomous exploration is designed for test environments. Irreversible actions, accidental deletions, or access to systems outside the test environment must be controlled by the test environment itself — not by the AI agent. This applies equally to any AI agent.

Depth limits can be specified in the test description and are generally respected in practice. However, there is currently no mechanism to technically enforce them. The agent can be stopped at any time if undesired behavior is observed during exploration.

AI Test Automation with QF-Test

How do we prevent the AI from accepting the current application behavior as correct?

2026-07-15T00:00:00+02:00

There is currently no reliable way to prevent the AI from treating the current application state as expected behavior. However, this is not the primary purpose of the feature — it is meant to give QA teams a structured starting point for the test structure, which they then review and refine.

For stable tests, it is recommended to replace the generated AI nodes with traditional QF-Test nodes wherever possible.

AI Test Automation with QF-Test

What options do I have when prompting for AI test generation?

2026-07-15T00:00:00+02:00

The prompt sent to the AI agent consists of two parts: a base prompt (defined in the library test suite qfs-ai.qft, overridable in your own test suite such as user-ai.qft) and your test description. This description can be as detailed as you like.

You can include tickets and test plans, acceptance criteria, business rules, or references to existing tests in the prompt. As with any AI application, there is no guarantee that all details will be fully taken into account — the more precise and complete your description, the better the result.

Note that overloading the model’s context window can lead to worse results. Keep your descriptions detailed, but focused.

AI Test Automation with QF-Test

Are AI-generated test suites in QF-Test reproducible?

2026-07-15T00:00:00+02:00

AI test generation in QF-Test is inherently non-deterministic: multiple runs of the same generation process produce different results. This is a fundamental characteristic of large language models.

If the test generation prompt remains the same across all runs, the structure and approach of the generated test suites will generally be similar — even if specific steps or wording differ. Treat each run as a draft to be reviewed and refined by your QA team — not as a finished test package.

AI Test Automation with QF-Test

QF-Test 10.1.3 available

2026-07-07T00:00:00+02:00

This release updates the bundled Jackson library to version 2.22.0 and fixes additional edge cases in the workaround for the UNC mapped drive issue with Java 25 on Windows.

QF-Test 10.1.3 available, new free accessibility check for your website

2026-07-07T00:00:00+02:00

Hello dear QF-Test users!

QF-Test 10.1.3 is now available – a new maintenance release that updates important libraries and more reliably compensates for a Java 25 bug on Windows when accessing UNC drives.

Also in this newsletter:

Is your website truly accessible to everyone – or are there hidden barriers you’re not yet aware of? We’ll find out for you: with a free accessibility check for your website.

Best regards,
your QF-Test team

Download QF-Test

Are you already using the latest version of QF-Test?

This release updates the bundled Jackson library to version 2.22.0 and fixes additional edge cases in the workaround for the UNC mapped drive issue with Java 25 on Windows.

Download QF-Test 10.1.3

To the Release Notes
Available from 2026-07-07

Events in 2026

QF-Test Basics: training courses via webinar

📆September 21–24, 2026 conducted in German

📆October 5–8, 2026 in English

More about the training courses

4 days, 2 × 2.5 hours each
Effective and rapid knowledge transfer
Small groups up to 8 participants
You can interact with the trainers and ask questions at any time.

Individual QF-Test company trainings

Would you like a training course which is individually tailored to your company? Just send us an email to service@qftest.com.

Ask our service team for a quote

News

New: Accessibility Check

Accessibility has been a legal requirement since June 2025 (European Accessibility Act). Our accessibility experts will analyze your website free of charge using QF-Test, based on WCAG criteria – including an interactive report and concrete recommendations for action.

➜ Request a free consultation

Agentic testing with AI agents and an MCP server

In an interview, Max Melzer explains how QF-Test integrates agentic testing step by step — and why it’s more than just a buzzword.

➜ Read the blog article now

From our YouTube Channel

A quick run through QF-Test

In just a few minutes, this video gives you a compact overview of all the key features of QF-Test — from Capture & Replay to scripting and component recognition, all the way to reports and Jenkins integration. Perfect for anyone who wants to get up to speed with QF-Test quickly or introduce it to a colleague.

➜ Watch the video now

Visit our YouTube channel to subscribe and follow us on LinkedIn.

QF-Test: Agentic testing with AI agents and an MCP server

2026-06-30T00:00:00+02:00

AI agents such as Claude Code, Cursor, or GitHub Copilot have long been part of everyday work for many development teams – they write code, refactor it, and suggest solutions, often without a human having to initiate every single line. The obvious question that follows: why shouldn’t the same agents take over testing as well?

This is exactly the question QF-Test addresses – our tool for professional UI test automation. In a recent interview “How QF-Test Makes Agentic Testing Possible”, our software developer and trainer Max Melzer explained to mgm technology partners how we are integrating agentic testing into QF-Test step by step – and why this shift is more than just a new buzzword.

Why test automation is changing right now

With the rise of powerful AI coding agents, expectations are shifting: teams no longer just want to run tests automatically – they want to delegate the entire testing process, from planning to evaluation, more heavily to AI. “Our customers are incredibly interested in figuring out which parts of the testing process they can hand off to AI,” says Max Melzer. This is precisely where our staged approach to agentic testing comes in.

Three levels of agentic testing

We are deliberately developing agentic testing in QF-Test in several stages that build on one another.

Level 1 – AI as a semantic validator (already available): Some test results cannot be verified with a simple target/actual comparison, such as the responses of an integrated chatbot. QF-Test can pass such results to a language model for evaluation, which assesses whether the response is plausible in terms of content. This turns rigid string comparisons into a semantic check.

Level 2 – AI generates test suites (from QF-Test 11): Instead of recording tests manually, AI will provide an initial draft in the future – based on existing test plans or tickets, or by exploring the application on its own and identifying testable areas. The expectation here is realistic: “It’s never the case that you can just take it and say: we’re done now,” says Max Melzer. “But it takes a lot of work off your plate — especially at the start.” The first draft is the basis that experienced testers refine further – not a finished test package without human oversight.

Level 3 – QF-Test as an MCP server (the real breakthrough): With QF-Test 11, the tool gains an integrated MCP server. Via the Model Context Protocol, AI agents such as Claude Code can then access QF-Test’s capabilities directly – launching applications, running tests, checking results – without anyone having to open QF-Test manually. An experimental preview of this MCP server is already available as a public preview, and the first customers are already integrating it into their CI/CD pipelines.

QF-Test Connected MCP Server (Public Preview)

What sets QF-Test apart from specialized tools

Other tools specializing in web testing now offer MCP support as well. For QF-Test, the decisive difference lies in its platform breadth: we test native Windows applications, Java UIs, Android and iOS apps, and PDF documents using the same approach as web applications. Anyone running a heterogeneous application landscape in their enterprise environment – as is usually the case – gets a single test agent for all areas instead of having to use a separate tool for each platform.

Outlook: what’s coming with QF-Test 11?

Test suite generation and the production-ready MCP server will be introduced with QF-Test 11, which is planned for 2026. Interested customers and partners can already get preview versions, so that real feedback from real-world projects can flow into further development.

One thing remains important: agentic testing does not replace experienced testers. AI-generated test suites provide a structured starting point – the professional validation and further development remain the responsibility of the QA teams.

Learn more: Read the full interview with Max Melzer, software developer and trainer at QF-Test, at mgm technology partners: “How QF-Test Makes Agentic Testing Possible”.

More details about the AI integrations in QF-Test

AI-driven test automation with QF-Test

AI agents in action: autonomous test generation and MCP with QF-Test 11

A Quick run through QF-Test

2026-06-26T00:00:00+02:00

The most important features of QF-Test summarized.

Introduction: Supported technologies
Tree structure, variables, capture & replay
Documentation: Tutorial, manual, (starter)videos
Test execution and reports, Connection to build tools: Jenkins
Scripting: Jython, Groovy, JavaScript
Component recognition
Further features
Help from QFS: blog, training and support

Transcript

Welcome! In the next few minutes, we’ll show you how QF-Test helps teams build stable, maintainable UI test automation across web, desktop, and mobile applications.

QF-Test supports a wide range of technologies – from Java desktop UIs and modern web apps to APIs, mobile apps, PDFs, and hybrid applications.

Tests in QF-Test are displayed in a user-friendly graphical tree view. This tree contains action nodes such as mouse clicks and so-called check nodes that verify properties of your application’s user interface.

Control structures like loops or if/else decisions are also supported by this tree. Setting and using variables is likewise straightforward using the QF-Test interface.

For better modularization – that is, for reusing previously created test steps – QF-Test provides test steps, test cases, test sets, and so-called procedures. All of these can be created and managed directly in the tree view.

Test Recording

The easiest way to create tests in QF-Test is via capture & replay. You start a test recording using the record button in QF-Test and then perform the desired steps in your application.

At the heart of QF-Test is a graphical, tree-based view of your tests that makes complex test logic transparent and maintainable – even for large test suites. After stopping the recording, the executed steps appear in the QF-Test tree view as individual nodes. You can then reorder and edit them, for example using drag and drop.

You can find detailed information about the nodes in the graphical tree and about test creation in the extensive QF-Test documentation.

The tutorial includes a quick-start guide that shows you how to set up your application with its UI technology in QF-Test.

QF-Test also comes with an extremely comprehensive and user-friendly manual that describes all features of QF-Test and includes a powerful search function and navigation aids.

And there’s also the QF-Test blog, where new tips and tricks for using QF-Test are published regularly.

In addition to this wealth of written information, you’ll find overview videos and QF-Test basics videos on the QF-Test website under “Videos.” These guide you step by step through testing your application with QF-Test, creating test cases, evaluating test results, and much more.

Test Execution and Evaluation

Once you have recorded your first test cases with QF-Test, you can execute them either directly from within QF-Test using the play button or via the command line using the so-called batch mode.

At the end of each test run, you receive a detailed QF-Test log showing all executed steps.

In case of errors, the log contains the error message along with detailed screenshots.

QF-Test also generates summary reports for you in either HTML or JUnit XML format, which makes it easy to integrate QF-Test into build tools such as Jenkins or TeamCity.

Here you can see an example of a QF-Test HTML report.

For execution via Jenkins, QF-Test provides its own Jenkins plugin, which you can install from the Jenkins plugin directory.

Videos covering test execution, test evaluation, and Jenkins integration are also available on our video page.

Scripting

In addition to the action nodes provided by QF-Test – such as mouse clicks, checks, text input, and text extraction – QF-Test also allows you to integrate your own code into test runs. This is done using so-called script nodes.

Scripts can be implemented in the scripting languages Jython (a Python derivative), Groovy (a Java derivative), or JavaScript.

There are two types of script nodes: SUT script nodes, which allow you to access your test application, and server script nodes, which let you implement and execute arbitrary code during a test run. The possibilities offered by these scripts are virtually unlimited and are, of course, described in the QF-Test manual in the “Scripting” chapter, as well as in several videos on our website.

Component Recognition

One of QF-Test’s key strengths is its reliable detection and re-detection of individual elements of a graphical user interface. This means your tests don’t break just because a button moves a few pixels or the layout changes.

QF-Test refers to these tracked elements as “components.” Components are recorded together with their corresponding actions when creating a test suite.

From a recorded action such as a mouse click, you can easily navigate to the associated recorded component via the context menu. There you’ll see that components are not identified solely by X-Y coordinates, but also by other properties – for example, in this case, by their label.

If available in the application under test, components can also be recognized using IDs or names defined by the developers. Assigning meaningful names to the most important components of your application results in very stable and robust test cases.

QF-Test’s component recognition algorithm can also be adapted and extended in many ways using so-called resolver scripts.

SmartID

For even more flexibility, AQF-Test allows you to dynamically address available components using so-called SmartIDs instead of previously recorded components. To do this, you select the recognition criteria that are most meaningful for your component and specify only those using the compact SmartID syntax.

For simple use cases, this allows you to avoid maintaining component nodes and even manual component recording altogether.

CustomWebResolver

Using a so-called CustomWebResolver, you can also make your web application and the UI components of the framework you are using easier to test with QF-Test.

Here, you define a kind of translation table between the properties of your UI component library and QF-Test’s component concept. Once this is done, QF-Test can record much more stable and intuitive tests and checks for your application’s UI elements.

For certain JavaScript component libraries such as Vaadin, Angular Material, ZK, and others, QF-Test already provides such integrations. If your application supports accessibility via the ARIA standard, these features can also be used out of the box with QF-Test.

Components in the Documentation

Details about component recognition and resolver concepts can of course be found in the QF-Test manual.

In particular, we recommend the “Components” chapter in the user manual, as well as the chapters “Scripting,” “Web,” and “APIs for Extensions,” which contain detailed descriptions of all resolver interfaces.

Naturally, there are also several videos on this topic available.

Additional Features

By now, we’ve explored many ways to create UI tests with QF-Test.

QF-Test offers many additional features for test design and for working efficiently with the tool itself:

Dependencies in QF-Test are a useful way to execute preconditions and postconditions for test cases efficiently and only when necessary.

Data drivers enable data-driven testing. This means you create a test case once in QF-Test, and QF-Test automatically repeats it once for each available dataset from an Excel file, SQL database, or other sources.

There is an integrated debugger that allows you to analyze test cases step by step. Skip nodes, repeat them, or even move the current execution point. QF-Test also lets you to inspect and modify the current variable values.

In the QF-Test context menu, you’ll find various small helpers – such as the “Convert Node” command and many others – that enable fast refactoring or simple static analysis of your test suites.

You can organize test suites into projects to represent complex project structures.

All of these features are, of course, documented in videos and the manual.

There you’ll also find tips and tricks, for example for “distributed test development” or instructions on how to perform load testing with QF-Test.

Conclusion

Whew – that was a lot of interesting features that QF-Test offers for efficient and robust test automation.

If you’re now interested in trying out QF-Test yourself and using it with your project, visit the QF-Test website at qftest.com, click on “Free Trial,” and get a free trial license today so you can take advantage of the many QF-Test features. This also gives you free access to our well-regarded support team.

So, if you’re looking for reliable, maintainable UI test automation backed by excellent documentation and support, give QF-Test a try.

QF-Test 10.1.2 available

2026-06-23T00:00:00+02:00

This release adds support for Q12-TMT version 5, improves uploading of test results to Q12-TMT and Xray for larger amounts of data, and allows extending the embedded AI providers via plugins. Several libraries have been updated.

Free accessibility check

2026-06-17T00:00:00+02:00

New: Our Experts Analyze Your Website with QF-Test Against WCAG Standards

WCAG compliance is now the law in the EU. Is your website truly accessible?

Many organizations and development teams know they need to act — but aren’t sure where to start when it comes to building digital products that are truly accessible to everyone.

That’s why we’re now offering a free Accessibility Check: our experts analyze your website with QF-Test against WCAG standards and deliver an interactive report with actionable recommendations.

Here’s how it works:

Share your URL
Our experts analyze your website against WCAG standards
You receive an interactive report with targeted recommendations within a few business days

No installation. No setup. Free and no strings attached.

Whether you need a one-time assessment or want to integrate accessibility testing permanently into your QA process — we’re here to help.

Request your free Accessibility Check

QF-Test 10.1.1 available

2026-06-02T00:00:00+02:00

This release adds support for uploading test results to Xray Data Center. In addition, Eclipse/SWT 4.40 alias “2026-06” and Electron 42 are now supported, and several libraries have been updated.

Get X-Ray vision: Integrate QF-Test results with Q12-TMT and Xray

2026-05-18T00:00:00+02:00

Q12-TMT and Xray Test Management are popular test management tools. In this special webinar, we will show you how to use the latest features in QF-Test to synchronize your test results with Q12-TMT and Xray. This way, you can combine QF-Test’s detailed reports with the strengths of these tools. The webinar will also include a brief introduction to Q12-TMT by our parent company, mgm technology partners.

Transcript

Chapter 1: Introduction

Once again, a very warm welcome to our special webinar. Today, we want to work together to answer the following questions:

How do I keep track of all these application tests?
How do I know what failed, when it failed, and how it failed?
And is it actually a serious problem or not?

The key term here is, of course, test management systems.

Today, we will focus especially on two systems with which QF-Test has become closely integrated since the latest version:

the well-known Xray system
and the powerful Q12-TMT

Joining us today are two recognized experts on the topic:

Gregor Schmid, the creator of QF-Test, who even after 25 years is still the driving force behind QF-Test development
and Thomas Rätzel from Leipzig, who has been a QA team lead at mgm for almost ten years and will introduce us to Q12-TMT

I myself am Pascal Bihler, also a developer at QF-Test, and I’ll be answering your questions alongside the presentation.

So let’s get started. Gregor, I’m already looking forward to it.

Thank you very much, Pascal, for the wonderful introduction.

The integration of test management tools into QF-Test is not a new topic. On the slide here on the right, you can see some earlier integrations, some of which have existed for a very long time, such as:

HP ALM
imbus TestBench

Recently, however, there has been increasing demand for a more direct integration with Xray.

Xray is currently probably the market leader based on Atlassian Jira — with all the advantages and disadvantages that come with it.

Our first approach was to investigate whether we could rewrite the JUnit reports so they could be uploaded directly into Xray. This is fundamentally possible, but very limited because it only works for this one exact use case.

At the same time, Q12-TMT was developed over the past few years. The tool is not yet very well known, but it comes from our parent company mgm Technology Partners and is already heavily used in many projects there — naturally also together with QF-Test.

As a result, there was also strong demand for tighter integration there.

Planned Features

For both test management tools, we are also working on:

Import/export of complete test sets
Hierarchies of test cases
Synchronization between systems

These features are not yet ready for release, but they will come in future versions.

What we implemented first — because this was where the greatest demand existed — was:

Uploading test results into the respective test management tools.

So this doesn’t remain too abstract, my colleague Thomas will now present Q12-TMT from a user perspective.

By the way, the concepts are very similar to Xray. Technically, we follow an almost identical approach for both systems — only the actual requests differ.

Thomas, over to you.

Chapter 2: Q12-TMT Demo

What is Q12-TMT?

Q12-TMT stands for: Test Management Tool

The tool is based on our in-house low-code platform A12.

Why did we develop our own testing tool?

Quite simply:

In the past, we worked with other tools, but certain features were missing. So we said: we are a software solutions company and capable of developing our own tool that maps our requirements exactly.

Basic Structure of TMT

TMT is relatively intuitive to use once you understand the basic structure.

Here we see an opened project. TMT supports multiple projects and different test management areas.

For this webinar, we are using the well-known Car Configurator as an example.

Project Overview

In the overview, you can see things such as:

Number of test cases
Processing status
Versions
Additional project information

On the left side are various navigation sections.

One important area is test automation.

For each test case, you can define whether it is:

already automated
still to be automated
intentionally manual

This effectively creates a small task board for automation engineers.

Test Cases and Test Runs

The two most important sections are:

Test Suites

This is where you define:

which test cases exist
how they are organized

Test Runs

Here you can see:

which tests were executed
results
statuses
start times
unique IDs

Graphical Analysis

Particularly interesting:

TMT offers graphical evaluations.

Using the so-called “fireworks diagram,” you can identify:

error clusters
concentrations of issues
open problem areas

Colors directly indicate:

Green = successful
Red = failed
additional status values

Structuring the Tests

The application can be structured however you like, for example:

by UI areas
functionally
by components

In the example:

Vehicles
Specials
Accessories

The structure is completely flexible and can be adapted to the respective testing strategy.

Structure of a Test Case

A test case typically contains:

Title
Status
Responsible persons
Automation status
Description
Jira links
Risk assessment
Preconditions
Test steps
Expected results

Additionally, formatting options are available for improved readability.

History & Versioning

A central feature of TMT is versioning.

This means:

new versions can be created from existing ones
histories are preserved
test cases continue across versions
changes are stored in a traceable way

Example:

Version 1.8
new version 2.0

Version Delta

A particularly important concept is the so-called version delta.

This means that new test cases are marked, and modified test cases are marked as well. This allows TMT to automatically recognize which test cases changed in a version. This becomes extremely helpful later during test execution.

Creating Test Runs

A new test run can be created very easily.

Afterward, test cases can be added:

Options:

automatically via version delta
manually via test suites
specifically by automation status

Test Execution

During execution, the tester can:

check off individual steps
document results
set statuses
continue later

Additionally, tasks can be assigned directly to specific people.

Previous Workflow

Up until now, the workflow looked like this:

Manage test cases in TMT
Link them with QF-Test via IDs
Transfer results back manually

Naturally, this was relatively time-consuming.

That’s why today’s focus is on how this process can be automated in the future.

Chapter 3: The QA Toolchain from a Single Source

A major advantage of Q12-TMT: it does not only run in the cloud.

There are:

a cloud variant
and an on-premise installation on your own servers

This allows customers to decide flexibly depending on their requirements.

In addition, support requests can be handled jointly through the familiar QF-Test support team.

Target Vision

The vision is a seamless workflow:

QF-Test → TMT/Xray → Risk-based analysis

This creates a complete QA toolchain.

Chapter 4: Uploading Test Results to TMT/Xray

Requirements

For this to work, you need:

automated tests
at least one test case with a linking ID

For example:

@tmtid
@xrayid

Linking the Systems

The connection is established via so-called doctags.

Example:

@tmtid C_2416
@xrayid XRAY-412
@xray-dc-id XRAYTEST-10

The following applies:

multiple QF-Test test cases can be assigned to one management test case
or vice versa

So this is an m:n relationship.

Chapter 5: Xray Integration

Configuration

For both systems, connection data must be configured:

TMT

Login
Project
Subproject
Version
Mapping

Xray

Jira access
Cloud/Data Center configuration
Ticket types
IDs

Test Execution

During the test run, errors are intentionally generated so that results become visible.

In the log, you can then see examples such as:

Exceptions
Failed checks
Components not found

HTML Reports

An HTML report is required for the upload.

This contains:

Screenshots
Error messages
Logs
Details

Upload to TMT and Xray

After the upload, the following are created automatically:

In TMT

new test runs
result overviews
error statuses
histories

In Xray

test executions
evidences (screenshots)
comments
report links

Differences in Status Values

Example in TMT:

Error → “Failed”
Exception → “Blocked”

The mapping can be customized individually.

History Tracking

An important point:

When tests are executed again:

history is preserved
new results overwrite the current status
old results remain traceable

Batch Upload

In practice, of course, people do not work with individual reports.

Typical dimensions: 30,000 to 40,000 test cases per nightly run.

Therefore, QF-Test also supports:

batch uploads
command-line calls
automated processing

Advantages of Batch Mode

multiple reports simultaneously
flexible configuration
encrypted secrets
option files
full automation

Chapter 6: Summary

To conclude, here are the key points once again:

What was demonstrated?

Linking QF-Test with TMT and Xray
Uploading automated test results
History tracking
Batch processing
Screenshots and reports directly in test management
Integration of manual and automated tests

Result

This creates a central platform for:

Test management
Automation
Analysis
Risk assessment
Histories

Many thanks once again to Thomas and Gregor for the detailed presentation — and best of luck with QF-Test and the test management tool of your choice.

QF-Test 10.1 available

2026-05-07T00:00:00+02:00

This release adds support for uploading test results to Q12-TMT and Xray Test Management, copying steps directly from a run log into a test suite and AI features can now be disabled entirely. The JRE has been pushed to Temurin OpenJDK 25 and numerous further libraries have been updated.

QF-Test 10.1 available: test management tool integrations – special webinar on May 18, 2026

2026-05-07T00:00:00+02:00

Hello dear QF-Test users!

QF-Test 10.1 is here – a new version that closely integrates your test processes with the test management tools Q12-TMT and Xray, offers greater control over AI features, and comes with a number of practical new additions and useful workflow improvements.

By the way: our next QF-Test basic training is coming up in September – spots are still available!

Best regards,
your QFS team

Download QF-Test

Are you already using the latest version of QF-Test?

Download QF-Test 10.1

To the Release Notes
Available since 2026-05-07

Next QF-Test special webinar

May 18, 2026, 3:30 PM (CEST) Get X-Ray vision: Integrate QF-Test results with Q12-TMT and Xray

Alternative date: Webinar in German on May 18, 2026, at 10:30 AM

More events in 2026

QF-Test Basics: training courses via webinar

📆September 21–24, 2026 in German

📆October 5–8, 2026 in English

More about the training courses

4 days, 2 × 2.5 hours each
Effective and rapid knowledge transfer
Small groups up to 8 participants
You can interact with the trainers and ask questions at any time.

Individual QF-Test company trainings

Would you like a training course which is individually tailored to your company? Just send us an email to service@qftest.com.

Ask our service team for a quote

News

Test Management Tool Integration with QF-Test

No more data silos: QF-Test automatically transfers test results to your test management system – no manual effort, no information loss. The result is end-to-end quality assurance: from requirement to test case to test result.

➜ Learn more about Test Management Tool Integrations with QF-Test

How to use the QF-Test AI integration with a free local model using Ollama

QF-Test 10 brings AI integration – local, free, and without the cloud: Learn how to connect QF-Test with Ollama and start experimenting with AI-powered testing directly on your own machine.

➜ Read the blog article now

Using GitHub Copilot CLI via Remote SSH from QF-Test

QF-Test 10 supports GitHub Copilot integration – this guest post shows you how to set up Copilot on a single central machine and use it across multiple QF-Test instances via SSH.

➜ Go to blog article

From our YouTube Channel

When tests become intelligent: AI-driven checks with QF-Test

In this special webinar, we’ll show you how to get the most out of the new AI integrations in QF-Test. With QF-Test 10, you can use AI to test non-deterministic UIs, validate UI components based on semantic criteria, generate test data, and much more.

➜ Watch the video now

Visit our YouTube channel to subscribe and follow us on LinkedIn.

QF-Test Version 10.1

2026-05-05T00:00:00+02:00

This version enables the upload of test results to Q12-TMT and Xray Test Management, the direct copying of steps from a log into a test suite, and AI features can now be completely disabled. The JRE has been upgraded to Temurin OpenJDK 25 and numerous additional libraries have been updated.

Detailed Release Notes QF-Test Version 10.1

QF-Test Version 10.1

2026-05-07

QF-Test Version 10.1.1

2026-06-02

This release adds support for uploading test results to Xray Data Center. In addition, Eclipse/SWT 4.40 alias “2026-06” and Electron 42 are now supported, and several libraries have been updated.

QF-Test Version 10.1.2

2026-06-23

QF-Test Version 10.1.3

2026-07-07

This release updates the bundled Jackson library to version 2.22.0 and fixes additional edge cases in the workaround for the UNC mapped drive issue with Java 25 on Windows.

Using GitHub Copilot CLI via Remote SSH from QF-Test

2026-04-01T00:00:00+02:00

With QF-Test 10, it is possible to integrate third-party AI models such as GitHub Copilot into QF-Test. In the case of Copilot, it is usually necessary to have the Copilot CLI installed on the same system as QF-Test.

However, there are situations where you cannot install the Copilot CLI on your test machines for technical or security reasons, or if you want to run multiple parallel QF-Test instances via Daemon mode.

For such cases, this guest article by long-time QF-Test user Irfan Yigit shows you how to set up Copilot on a single central machine and establish an SSH network connection to your test machines. You can then use your GitHub Copilot AI models with QF-Test via SSH.

Attention: Even though the approach described here still works, it is not compatible with the advanced tool-use-enabled AI features like the AI Instructions in QF-Test 11.

Prerequisites

To set this up on a Windows system, OpenSSH is required. OpenSSH must be installed on both the client VM and the target VM.

The client VM additionally needs QF-Test (10.0 or newer) installed. The target VM must have a current GitHub Copilot CLI installation, and the GitHub login (/login) must have been completed within the SSH environment.

To use GitHub Copilot CLI via remote SSH reliably, an SSH key is required, because OpenSSH cannot handle SSH password prompts during automated remote calls (such as those triggered from QF-Test). SSH key authentication is needed solely to establish a passwordless, stable SSH connection.

Step-by-Step Guide

Preparation on the Client VM

1. Create the .ssh directory (if it doesn’t exist, e.g. C:\Users\Administrator\.ssh)

New-Item -ItemType Directory -Path "$env:USERPROFILE\.ssh" -Force | Out-Null

2. Generate an SSH key (ed25519) on the client VM (without a passphrase)

ssh-keygen -t ed25519 -C "qftest-remote" -f "$env:USERPROFILE\.ssh\id_ed25519"

Simply leave the passphrase empty (press Enter twice).
The generated public key (…/.ssh/id_ed25519.pub) will be needed on the target VM later.

Preparation on the Target VM

1. Set Access Control Lists (ACLs) correctly

Windows OpenSSH only accepts keys if the file is in the right location and the permissions are set with the correct ACLs. The file C:\ProgramData\ssh\administrators_authorized_keys is created and secured as follows:

icacls C:\ProgramData\ssh\administrators_authorized_keys /inheritance:r
icacls C:\ProgramData\ssh\administrators_authorized_keys /grant 'Administrators:F'
icacls C:\ProgramData\ssh\administrators_authorized_keys /grant 'SYSTEM:F'
Restart-Service sshd

2. Add the public key

Paste the contents of id_ed25519.pub from the client VM into the administrators_authorized_keys file on the target VM and save it (one key per line).

3. Log in to Copilot CLI in the SSH environment on the target VM (once)

Copilot stores its login credentials locally in the respective user profile. The login must be completed beforehand — either directly on the target VM or via SSH, depending on whether different Windows users are involved.

Once the Copilot login is saved in the SSH environment, Copilot can be fully scripted via remote SSH from QF-Test.

Run the following in PowerShell if all client VMs should interact with the same user and SSH environment:

SSH directly to the target VM: ssh -i ~/.ssh/id_ed25519 Administrator@<target-IP>
Start Copilot: copilot
Start login: /login
Confirm the device code in the browser.

Functional Test (Client VM → Target VM, headless)

Run the following command on the client VM in PowerShell:

ssh -i ~/.ssh/id_ed25519 Administrator@<target-IP> "copilot -p 'Say hello' --stream on"

Troubleshooting

Test SSH key login from the client VM

Verify that SSH works without a password using the SSH key (prerequisite for QF-Test):

ssh -i $env:USERPROFILE\.ssh\id_ed25519 Administrator@<target-IP> 'echo OK'

If OK appears → key authentication is working.
If there is an error: check the SSH keys or ACLs on the target VM.

Connect Copilot CLI to QF-Test via SSH

Once everything works, follow these instructions from step 2:

Tutorial: Using GitHub Copilot with the QF-Test AI Integration

Since QF-Test 10, AI-driven capabilities are integrated directly into your testing workflow. This post shows how to connect GitHub Copilot to QF-Test using a simple custom model and the Copilot CLI.

Max Melzer

09/02/2026

Make the following adjustments to the ai.addCustomModel script (insert the correct user, path and IP for your setup):

ai.addCustomModel("GitHub Copilot", (msg) -> {
    def remoteUser = "Administrator"
    def remoteHost = "192.168.0.2" // IP of target VM
    def remoteCmd = "cmd /c \"C:/Users/Administrator/AppData/Local/GitHubCopilotCLI/copilot.exe --silent --stream off --model claude-sonnet-4.6 --prompt \\\"${msg}\\\"\""
    def cmd = [
        "ssh",
        "-o",
        "StrictHostKeyChecking=no",
        "${remoteUser}@${remoteHost}",
        remoteCmd
    ]

    def proc = cmd.execute()
    proc.outputStream.close()
    proc.waitFor()

    return proc.in.text.replace("● ", "")
})

Learn more about the AI integrations in QF-Test 10:

AI-driven test automation with QF-Test

QF-Test 10.0.3 available

2026-03-11T00:00:00+01:00

This maintenance release adds support for Eclipse/SWT 4.39 alias “2026-03”, updates several libraries and fixes a number of bugs.

How to use the QF-Test AI integration with a free local model using Ollama

2026-03-09T00:00:00+01:00

QF-Test has always been about reliable, maintainable test automation for web, desktop, Java-based, and mobile applications. With the new AI integration in QF-Test 10, you can enhance your tests with AI-driven insights — and the best part is, you don’t need to rely on cloud services. In this post, we’ll show you how to connect QF-Test to a locally running, free AI model using Ollama, so you can start experimenting with AI-enhanced testing right on your own machine.

Step 1: Set up Ollama

To get started, you’ll need to install Ollama on the machine where your tests run. Ollama provides free, locally hosted AI models that powerful enough for the more basic parts of QF-Test’s AI integration.

Download and install Ollama from the official website: https://ollama.com/ (You don’t need any account).
Start the Ollama server by opening a terminal and running:

bash ollama serve
In another terminal, download a model, which typically is a couple of gigabytes:

bash ollama pull llama3.2

By default, Ollama will host the model at http://localhost:11434 as long as ollama serve is running. You can now use this endpoint in QF-Test to send AI requests locally — no internet connection required.

Step 2: Configure QF-Test to Use the Local AI

You can connect the Ollama server to QF-Test convieniently via the QF-Test Options dialog, accessible via QF-Test → Options → AI Integration. Click the “plus” icon to add a new row to the “AI Configurations” table and enter the model details:

Type: “Ollama”
Name: “Local AI” (or whatever you like)
URL: “http://localhost:11434”
API key: “” (leave blank)
Model name: “llama3.2” (the name of a model you added to Ollama via ollama pull)

QF-Test also makes it easy to integrate an AI model via the ai scripting module, if you prefer the scripting approach.

Here’s a minimal example of a server script that connects QF-Test to your locally running Ollama model:

// Configure the AI model
ai.setDefaultConfig("Ollama", "http://localhost:11434", "", "llama3.2", displayName: "Local AI")

// Make a request to the AI and print it to the terminal
print(ai.ask(
  "What is the answer to life, the universe and everything?",
  configName: "Local AI"
))

Let’s break down what’s happening:

ai.setDefaultConfig(...):
This line registers the model with QF-Test. You specify:
- The type of endpoint (“Provider”) to use (Ollama)
- The local endpoint url (http://localhost:11434)
- An empty string for the API key (not needed for local models)
- The model name (llama3.2 in our case)
- A friendly display name (Local AI) for use in the UI
- ai.ask(...):
  This line sends a prompt to the AI model. The configName ensures it uses the local configuration we just defined. The result is returned directly and printed in the QF-Test terminal.

Step 3: Use AI in your tests

Beyond this toy example, you can now leverage your local AI model directly in your test cases:

AI Instruction (QF-Test 11)
With QF-Test 11 and the new AI Instruction, you can give the AI tasks in natural language as part of your tests. The AI will be able to interact with the entire SUT, including performing mouse interactions, keyboard entry, and checks.
Test data generation (QF-Test 11)
QF-Test 11 lets you use natural language to fill out Data Tables with custom test data, generated in seconds by your chosen AI model.
Check Text with AI
The AI integration can be used in a Check Text with AI node. This is perfect for situations where you want QF-Test to validate text in your application UI dynamically. For example, you could check if a text matches a natural language description or even check if it’s in the expected language. To learn more, see the documentation here: Check Text with AI node
AI Scripting Module
For advanced automation, the ai scripting module gives you full programmatic control over AI requests in QF-Test: AI scripting module documentation

The advantages of running locally

Running a local AI model has several advantages:

Privacy: Your test data never leaves your machine.
Performance: Local inference can be faster than cloud requests.
Cost-free: No API subscription needed for experimentation.

By combining QF-Test’s robust automation framework with AI insights, you can enhance your tests, automate language checks, or even generate test suggestions — all without leaving your enterprise environment.

What’s next

Once you have your local Ollama model running and integrated with QF-Test, try experimenting with:

Natural language validations in your test cases
Dynamic data generation for forms
Multilingual text checks

For more details on all AI integration options in QF-Test, check out our free special webinar:

[[qf.Preview(videos/2026-08-17-special-webinar-mcp)]]

With just a few steps, your tests can now become AI-aware while staying fully under your control. It’s time to explore the power of combining QF-Test with local AI models!

When tests become intelligent: AI-driven checks with QF-Test

2026-03-02T00:00:00+01:00

Materials

This video gives you a first look at the AI-powered features of QF-Test. For the latest developments and most current features, we recommend checking out our more recent videos on AI testing:

QF-Test 11 – Agentic AI features and more

With QF-Test 11 and the integrated MCP, QF-Test is ready for agentic AI workflows. In addition to several useful UI improvements, it is now possible to automatically create complex procedure calls directly during recording. In this video, we show you what’s new.

AI agents in action: autonomous test generation and MCP with QF-Test 11

Artificial Intelligence

A Large Language Model (LLM) auto-completes text prompts according to previously trained statistical connections.

Our Mission

QF-Test provides AI integrations that increase the productivity of test automation engineers without calling the quality of the results into question.

QF-Test builds on the expertise of QA professionals without replacing them.

AI in QF-Test will always remain optional.

„Bring Your Own Model“

More flexibility
No extra costs
Better data privacy

AI Configuration

Your key to all AI functionality in QF-Test

Check text with AI

Semantic text checks in the UI of the application under test.

Use cases:

Testing a chat bot integration
Checking the semantic content of text
Checking the language of text

ai.ask and the AI Scripting Module

Send LLM requests in any scripting context.

Use cases:

Test data generation
Advanced test run integrations

Test generation with QF-Test – Sneak Preview

Level 1: Test cases and test steps are generated from an existing test definition.
Level 2: QF-Test agent executes pre-planned test steps; the interactions are recoded. A robust, repeatable test is created.

QF-Test MCP Server

MCP (Model Context Protocol): Integrating external services into an LLM tool

Future versions of QF-Test Pro will include an integrated MCP server. This will enable agent-based workflows with QF-Test.

Advantages over other automation MCPs:

Controlling Windows, iOS, Android, Java, and web applications
Strong component recognition by combining QF-Test intelligence and artificial intelligence

The experimental QF-Test Connected MCP Server (Public Preview) allows integrating QF-Test into agentic workflows today.

AI and Test Result Evaluation

Explain test failures and suggest corrective actions
Analyze “component not found” errors
Analyze text comparison diffs
Summarize test reports

Your ideas are welcome!

What‘s the Price?

Basic AI features such as AI checks or test suite generation are and will remain included in the standard price of every QF-Test license.
“Bring your own model”: Costs for using AI itself may arise depending on the chosen model and provider.

In the future:

Advanced features such as integrating QF-Test into agent-based workflows via MCP will require a QF-Test Pro license.
If there is sufficient interest: Secure, privacy-compliant access to AI models directly via QF-Test.

QF-Test and AI – Special webinar on March 2, 2026 – register now for free

2026-02-11T00:00:00+01:00

Hello dear QF-Test users!

Get ready for the first QF-Test webinar of the year. On March 2, 2026 we will focus on “Artificial Intelligence”. Business software requires reliability, not experimentation. That’s why, in this special webinar, we explain how we are using AI in a targeted way – now and in the future – where it delivers real value, and how it helps you test more efficiently.

Best regards,
your QFS team

Next QF-Test special webinar

March 2, 2026, 3:30 PM (CET) When tests become intelligent: AI-driven checks with QF-Test

Alternative date: Webinar in German on March 2, 2026, at 10:30 AM

Download QF-Test

Are you already using the latest version of QF-Test?

The maintenance release QF-Test 10.0.2 increases flexibility for LLM communication (for example, for the AI Check node). It also improves the stability of communication with the QF-Test license server and fixes a few bugs.

Download QF-Test 10.0.2

To the Release Notes
Watch the Release video
Available since 2026-01-15

Events in 2026

QF-Test Basics: training courses via webinar

➡️February 23–26, 2026 in German

📆March 23–26, 2026 in English

More about the training courses

4 days, 2 × 2.5 hours each
Effective and rapid knowledge transfer
Small groups up to 8 participants
You can interact with the trainers and ask questions at any time.

Individual QF-Test company trainings

Would you like a training course which is individually tailored to your company? Just send us an email to service@qftest.com.

Ask our service team for a quote

News

Tutorial: Using GitHub Copilot with the QF-Test AI Integration

We show how to connect GITHub Copilot to QF-Test using a simple custom model and the Copilot CLI.

➜ Go to tutorial

Testing ZK Applications with QF-Test

The great thing about ZK has always been that you can build web applications without having to deal with writing and maintaining HTML and JavaScript code.

➜ Read the blog article now

BITMARCK case study: best practice for mobile app testing

Our customer BITMARCK Software GmbH uses QF-Test to perform mobile regression testing for iOS and Android applications. The case study shows how QF-Test ensures the high quality of iOS and Android applications in every release cycle.

➜ To the case study

Case study ABS: automated nightly testing process saves significant time and effort

“QF-Test, as the best solution for automated testing of our Swing-based ERP system for the laundry business, has exceeded our expectations for over 15 years.”

➜ Read the case study now

Master complex systems with QF-Test

Based on the quality engineering strategy of Lilia Gargouri at mgm technology partners, our blog article shows how QF-Test helps organizations test software projects efficiently, scalably, and reliably.

➜ Read the blog article now

Partying in cozy alpine cabin vibes

In a relaxed atmosphere, full of coziness and great vibes, the QF-Test team took part in this year’s Winter Cabin Magic event hosted by our parent company, mgm technology partners.

➜ Read more

From our YouTube Channel

New video about QF-Test

Whether you’re building web apps, mobile experiences or desktop applications, QF-Test helps you deliver quality, faster.

➜ Watch the video now

Visit our YouTube channel to subscribe and follow us on LinkedIn.

Tutorial: Using GitHub Copilot with the QF-Test AI Integration

2026-02-09T00:00:00+01:00

Attention: With QF-Test 11, the workaround described here is no longer needed. You can connect the GitHub Copilot and Claude Code CLI interfaces to QF-Test 11 directly via Options → Artificial Intelligence → AI Configurations.

QF-Test is a comprehensive test automation solution built for Web, Desktop, Java-based, and Mobile applications, with a focus on long-term maintainability and enterprise-ready reliability. With the launch of QF-Test 10, AI-driven capabilities are now integrated directly into your testing workflow. This post shows how to connect GitHub Copilot to QF-Test using a simple custom model and the Copilot CLI.

Usually in QF-Test, AI providers are set up via Options → Artificial Intelligence → AI Configurations. GitHub Copilot is an exception because it doesn’t expose a standard API endpoint with a URL. Therefore, you cannot add Copilot in Options → Artificial Intelligence → AI Configurations. The good news: you can still integrate Copilot by registering your own custom model in QF-Test that calls the GitHub Copilot CLI.

What you’ll need

QF-Test 10 or later.
Access to GitHub Copilot and GitHub Copilot CLI. As of now, a free GitHub account on the “Free” Copilot plan is enough to experiment with the Copilot CLI.
Basic familiarity with scripting in QF-Test.

Step 1: Install and configure the GitHub Copilot CLI

Install the GitHub Copilot CLI
Follow the official instructions
Log in from your Terminal
Run copilot login
Verify it works
Try a quick prompt: copilot --prompt "Hello World"

If that prints a response from Copilot, you’re ready to connect it to QF-Test.

Step 2: Wire Copilot into QF-Test via a custom model

We’ll use ai.addCustomModel in a Server Script so QF-Test can talk to Copilot by launching the CLI as a subprocess. In QF-Test:

Create a new Server Script node (language: Groovy).
Paste the code below into the script.
Adjust the path to the copilot executable. /opt/homebrew/bin/copilot will only work if Copilot CLI was installed via Homebrew on macOS.
Run the script node.

ai.addCustomModel("GitHub Copilot", (msg) -> {
    def cmd = [
        "/opt/homebrew/bin/copilot",
        "--silent",
        "--stream", "off",
        "--model", "claude-sonnet-4.5",
        "--prompt", msg
    ]
    def proc = cmd.execute()
    proc.outputStream.close()
    proc.waitFor()

    return proc.in.text.replace("● ", "")
})

println(ai.ask("What is the answer to life, the universe and everything?", configName: "GitHub Copilot"))

What this does:

Registers a LLM model named “GitHub Copilot” with the QF-Test AI integration.
For each prompt (msg), QF-Test starts the Copilot CLI and returns the CLI’s text output back to QF-Test.
Prints the result of a sample ai.ask call in the QF-Test terminal.

Tip: You can change the model name passed to --model to your preferred Copilot model.

If you get an error saying Cannot run program "/path/to/copilot": error=2, No such file or directory, you must update the path in the first item in the cmd list to where the Copilot CLI is installed on your system.

If everything works, you can remove the println line at the end.

Step 3: Use Copilot with the QF-Test `ai` scripting module

Once the custom model is registered, you can use it from any script with ai.ask, for example:

def answer = ai.ask(
    "Generate a JSON string of test data in the following format: ...",
    configName: "GitHub Copilot"
)
rc.setLocal("data", JSON.parse(answer))

For more on the ai scripting module in QF-Test, see the QF-Test manual.

Step 4: Validate UI text with “Check text with AI”

You can also bring Copilot into your test checks. The “Check text with AI” node lets you have the AI verify UI elements in your application using natural language. In the node’s “AI configuration” field, “GitHub Copilot” should automatically appear in the dropdown.

That’s it! Even though Copilot doesn’t expose a standard URL+API key endpoint, you can still use it inside QF-Test by registering a custom model that calls the Copilot CLI. From there, ai.ask helps you validate and generate data right in your tests, and “Check text with AI” lets you validate UI content in plain language. Happy testing!

For more details on all AI integration options in QF-Test, see our free special webinar:

AI agents in action: autonomous test generation and MCP with QF-Test 11

Using GitHub Copilot CLI via Remote SSH from QF-Test

This quick guide explains how to use the GitHub Copilot CLI via a remote SSH connection directly from QF-Test — including SSH key setup and troubleshooting.

Irfan Yigit, ASC Technologies

01/04/2026

AI-driven test automation with QF-Test

Testing ZK Applications with QF-Test in 2026

2026-02-05T00:00:00+01:00

This text was originally published as a ZK Small Talk. ZK is a framework for building web applications with Java and a long-standing partner of QF-Test.

The great thing about ZK has always been that you can build web application without having to deal with the hassle of writing and maintaining HTML and JavaScript code. You define your application UI in concise ZUML markup and little richlets written in Java, you can write unit tests for your business logic and even use ZATS to test your UI.

End-to-end tests for automated testing of a Swing-based ERP solution

2026-02-03T00:00:00+01:00

About ABS

ABS is a leading software company for laundry management systems, specialized worldwide in the laundry and textile rental industry. Our software has evolved into a comprehensive and integrated ERP solution for industrial laundries—including route accounting and contract management.

Automated End-to-End Testing without programming skills

After conducting extensive research on multiple automated testing solutions, we selected QF-Test as the best fit for our Java Swing based laundry ERP system.

A key advantage was the ease of use, which enabled our team to quickly build business flow tests without requiring advanced programming knowledge.

This enabled us to

automate critical flows early on,
significantly reduce manual testing effort, and
accelerate delivery.

Expanding test coverage

Over time, the QF-Test tool has continued to mature, allowing us to extend our automated test coverage beyond Java Swing to web applications, mobile applications, and REST web services.

For unsuccessful test flows, QF-Test provides highly valuable diagnostic data, including

screenshots,
detailed step-by-step error information, and
error messages.

Additionally, by integrating Jython scripts into our dependencies, we are able to validate error log files, giving us deeper insights into failures and improving root-cause analysis.

Automated nightly testing saves time and effort

We implemented a fully automated nightly testing process using Jenkins that executes all QF-Test test runs automatically and provides comprehensive results.

These reports are extremely helpful for identifying code defects as well as opportunities to improve test flows.

The ability to run these automated tests on both master and feature branches has saved our team substantial amount of time and effort compared to manual end-to-end testing.

Outstanding support

Beyond the technology itself, our collaboration with the QF-Test team has been outstanding. Their support team is responsive and knowledgeable, consistently helping us solve challenges when needed. They also regularly offer webinars that provide valuable insights into new features, enhancements, and best practices, ensuring we continuously get more value from the tool. After more than 15 years of use, QF-Test remains a trusted partner in our automated testing strategy.

Conclusion

QF-Test, as the best solution for automated testing of our Swing-based ERP solution for the laundry industry, has exceeded our expectations for over 15 years. The intuitive approach enabled us to rapidly create end-to-end tests with minimal programming effort, drastically reducing manual testing needs. Thanks to the continuous innovation from the QF-Test team, we have since expanded our test coverage to include mobile applications, web applications, and web services, making QF-Test a trusted long-term partner.

Anca Stamatopol, QA Automation Team Lead, ABS Laundry Business Solutions

Mobile Regression Testing for iOS and Android

2026-02-02T00:00:00+01:00

Expanding the GKV Software Standard BITMARCK_21c|ng

About BITMARCK

As a leading digitalization partner in the statutory health insurance sector, BITMARCK is accelerating digital transformation within the industry through innovative products and services. The foundation for this is the GKV software standard BITMARCK_21c|ng, which is used by affiliated healthcare funds. Clients of the BITMARCK Group include company and guild health insurance funds, as well as DAK-Gesundheit and other substitute health insurers—over 30,000 employees and around 35 million insured individuals within statutory health insurance (GKV) benefit from BITMARCK’s IT services. More than 80 percent of German statutory health insurers are clients of the group. With more than 1,900 employees, BITMARCK generates annual revenues of more than half a billion euros.

The Challenge: Seamless Quality Assurance for Mobile Channels

After successfully implementing test automation for desktop clients (Web and Swing), BITMARCK GmbH faced the challenge of bringing the quality of its native iOS and Android apps within the GKV software standard BITMARCK_21c|ng up to the same high level.
This required a forward-looking and flexible extension of the existing test automation framework in order to:

Ensure a consistent user experience and functionality across both mobile operating systems (iOS and Android).
Quickly and efficiently create new mobile test cases and integrate them into the existing set of over 4,500 regression tests.
Integrate mobile test coverage into the Continuous Delivery (CI/CD) pipeline to ensure stability with every release cycle.

The Solution: Leveraging the QF-Test Platform for Mobile

The existing foundation, consisting of QF-Test and the jointly developed Multi-Client Recorder, served as the basis for the mobile expansion.

Mobile Regression Testing Strategy in Detail

BITMARCK focused on securing its native iOS and Android apps, which serve as important customer and employee portals, by taking the following steps:

Technology Selection and Integration: Thanks to QF-Test’s platform-agnostic nature, the framework could be directly extended to native mobile apps. Integration was achieved via QF-Test, enabling seamless use of both physical devices and emulators.
Mobile Test Object Recognition: Close collaboration with QFS enabled the early implementation and optimization of mobile test object recognition. This ensured robust test cases that are resilient to minor UI changes across both mobile platforms.
Specific Mobile Interactions: Specific mobile interactions (such as swiping and handling virtual keyboards) are captured by the recorder and incorporated into test cases.
Result: Mobile test coverage has been successfully integrated into the CI/CD pipeline and now ensures the quality of iOS and Android applications in every release cycle.

The Benefits

Cross-Platform Efficiency: The Multi-Client Recorder optimizes test automation for Web clients, Swing clients, and native iOS and Android apps—all under one unified framework.
Comprehensive Coverage: Integration allows management and execution of regression tests across all client architectures, including the new mobile coverage.
Accelerated Test Development: The recorder’s intuitive design carries over to mobile development, simplifying the creation and maintenance of test cases while significantly reducing maintenance effort.
Maximum Mobile Software Quality: By expanding its regression testing strategy, BITMARCK Software GmbH ensures the highest quality for its mobile solutions for statutory health insurance.
Continuous Delivery: Mobile coverage has become part of the CI/CD pipeline, guaranteeing the stability of native apps in every daily run.

Conclusion

The successful integration of mobile regression testing for iOS and Android using QF-Test and the Multi-Client Recorder highlights the flexibility and future-readiness of BITMARCK GmbH’s test automation strategy. This expansion safeguards the growing importance of mobile channels and reaffirms the commitment to the highest quality standards in software development.

Dirk Kruck, Test Engineer, BITMARCK Software GmbH

QF-Test Featured in mgm technology partners’ Blog on Quality and Efficiency Strategy

2026-01-29T00:00:00+01:00

In the latest post on the mgm technology partners blog, “How Quality Engineering Makes Complex Systems Manageable”, Lilia Gargouri presents their holistic approach to quality engineering – with a focus on sustainable, scalable quality assurance in complex software projects. Unlike traditional testing, this approach emphasizes a systematic interplay of architecture, processes, data, models, and tools, making quality throughout the entire software lifecycle both predictable and controllable.

A particularly interesting aspect

The article highlights the critical role automation plays in this approach—and this is where QF-Test comes in. As a powerful tool for automated end-to-end and UI testing, QF-Test delivers exactly the scalability and repeatability that complex applications require, helping teams use resources efficiently while ensuring high quality.

Why QF-Test matters for quality engineering

Automated tests that go beyond classic manual methods to ensure consistent, reproducible quality.
Support for different types of applications (web, desktop, Android, iOS applications, etc.), making it easier to integrate into diverse projects.
Contribution to a shift-left strategy, helping to prevent defects early in the development process and thereby reducing effort and cost.

Conclusion

Overall, the article demonstrates how test automation—and especially the use of QF-Test as part of a test and quality engineering strategy—helps manage the challenges of complex software environments and ensures the highest quality standards.

How Quality Engineering Makes Complex Systems Manageable by Lilia Gargouri, Head of Quality Engineering at mgm technology partners

QF-Test and mgm technology partners partying in cozy alpine cabin vibes

2026-01-21T00:00:00+01:00

With delicious food, cheerful curling and good music, there was definitely no shortage of fun. By the end, everyone was on the dance floor. It was an all-around successful evening that strengthened team spirit and created many wonderful shared memories.

QF-Test 10.0.2 available

2026-01-15T00:00:00+01:00

This maintenance release increases flexibility for LLM communication (for example, for the AI Check node). It also improves the stability of communication with the QF-Test license server and fixes a few bugs.

Maintenace release QF-Test 10.0.1 & season’s greetings by QFS

2025-12-18T00:00:00+01:00

Hello dear QF-Test users!

As we approach the end of another remarkable year, we would like to take a moment to thank you for your trust, loyalty, and excellent collaboration. Together, we have once again achieved a great deal this year:

With QF-Test 9 and 10, you benefit from powerful enhancements such as WebAPI testing and AI-driven validation, improved accessibility testing and much more flexible image-based testing capabilities. We look forward to your feedback on our new QF-Test editions.

Through continuous development, we keep our finger on the pulse. Accordingly, we are releasing maintenance version 10.0.1 today with several important bug fixes.

Features for integrating the test management tools Q12-TMT and Xray as well as support for Oracle Forms are currently under development and will also be included in QF-Test 10 soon with upcoming minor updates.

We’re excited to continue this journey with you in 2026! We wish you and your families a relaxing and restful Christmas season. Treat yourself to some quality time, enjoy the festive season, and recharge your batteries for the coming year.

With warm regards and best wishes for a successful, healthy, and happy 2026,
your QFS team

Maintenace release QF-Test 10.0.1 & season’s greetings by QFS

2025-12-18T00:00:00+01:00

Hello dear QF-Test users!

Through continuous development, we keep our finger on the pulse. Accordingly, we are releasing maintenance version 10.0.1 today with several important bug fixes.

With warm regards and best wishes for a successful, healthy, and happy 2026,
your QFS team

Download QF-Test

Are you already using the latest version of QF-Test?

The maintenance release QF-Test 10.0.1 fixes startup issues under QF-Test 10.0.0 related to certain license files and addresses several other minor bugs.

Download QF-Test 10.0.1

To the Release Notes
Watch the Release video
Available since 2025-12-18

Events in 2026

Next QF-Test special webinar

March 2, 2026, 3:30 PM (CET) When tests become intelligent: AI-driven checks with QF-Test

Alternative date: Webinar in German on March 2, 2026, at 10:30 AM

QF-Test Basics: Training courses via webinar

February 23–26, 2026 in German

March 23–26, 2026 in English

More about the training courses

4 days, 2 × 2.5 hours each
Effective and rapid knowledge transfer
Small groups up to 8 participants
You can interact with the trainers and ask questions at any time.

Individual QF-Test Company Trainings

Would you like a training course which is individually tailored to your company? Just send us an email to service@qftest.com.

Ask our service team for a quote

News

Donations 2025

At QFS, we are pleased to once again support a number of nonprofit organizations with donations this year. Our employees also contribute by nominating projects that are particularly meaningful to them.

➜ These organizations are supported by QFS in 2025

From our YouTube Channel

New video about QF-Test

Whether you’re building web apps, mobile experiences or desktop applications, QF-Test helps you deliver quality, faster.

➜ Watch the video now

Visit our YouTube channel to subscribe and follow us on LinkedIn.

Donations 2025

2025-12-16T00:00:00+01:00

Welcome to QF-Test

2025-12-12T00:00:00+01:00

Meet QF-Test – our all-in-one platform for automated UI testing.

Whether you’re building web apps, mobile experiences or desktop applications, QF-Test helps you deliver quality, faster.

QF-Test is built for all kinds of users, from manual testers and business analysts to automation engineers and software developers.

You can create complete and complex automated tests without ever writing code – but of course you always have the option to augment your tests with our scripting engine.

Once you’ve created your first tests with QF-Test, you can effortlessly spot regressions in your application – less repetitive work, more confidence in every release.

While QF-Test started as a way to test Java UIs, it has continuously evolved to support many other UI technologies.

Whether on Windows, Linux or macOS, QF-Test reliably supports you in automating your Tests.

Now you can unlock the full potential of QF-Test and create your own automated tests with ease and precision.

If you are interested in testing your own application, contact us and try QF-Test for free at qftest.com

QF-Test 10 available

2025-12-09T00:00:00+01:00

Our new release QF-Test 10 takes test automation to the next level.

In addition to powerful enhancements like WebAPI testing and AI-driven validation, you will benefit from improved accessibility testing and much more flexible image-based testing capabilities.

We are also excited to introduce our new QF-Test editions. They make test automation simpler, more transparent, and better tailored to your specific needs. You can find more details in this newsletter.

QF-Test 10 with WebAPI Testing and new editions

2025-12-09T00:00:00+01:00

Hello dear QF-Test users!

Our new release QF-Test 10 takes test automation to the next level.

Best wishes,
your QFS team

Download QF-Test

Do you already use the latest version of QF-Test?

Download QF-Test 10.0

To the Release Notes
Watch the Release Video
Available since 2025-12-09

QF-Test is now available in the following editions

QF-Test Web – supports all common browsers, including accessibility testing, Electron applications and, new: APIs and web services

QF-Test Desktop – for Java programs and native Windows applications

QF-Test Mobile – for Android and iOS apps

QF-Test Pro – combines all technologies and additionally supports hybrid applications

The editions focus on the UI technologies and display only the relevant program features, making the QF-Test interface significantly leaner. Our manual is also optimized for each edition and contains only the information relevant to you.

Consistent with previous QF-Test versions, QF-Test Pro combines the technologies of the other editions and also supports hybrid applications.

Depending on the UI technologies being tested, using a dedicated edition — QF-Test Web, QF-Test Desktop, or QF-Test Mobile — can be advantageous, as it focuses the feature set accordingly.

We are confident that the new editions will allow you to make your test automation projects even more efficient, and we look forward to supporting you along the way.

Our valued existing customers do not need to take any action. You can continue to use QF-Test Pro as usual within the scope of your current licenses. Existing licenses and contracts will, of course, remain valid.

For early adopters who wish to expand their existing licenses under the previous scheme and pricing model, we offer the opportunity to request a corresponding quote until end of January 2026.

If you have any questions regarding the transition, you can contact our team at any time.

Get in touch with our service team now

Highlights in QF-Test 10

QF-Test 10 introduces powerful enhancements for WebAPI testing.

Create end-to-end HTTP requests, manage authentication, cookies, and proxies through dedicated nodes, and customize workflows to combine UI and API automation in hybrid scenarios.

The new “Check Text with AI” node and the “ai” scripting module enable the integration of externally hosted LLMs to perform dynamic text validations and handle non-deterministic UI behavior.

Accessibility testing has also been significantly improved, with YAML-based configuration and additional checks for keyboard focus visibility and correct usage of the “lang” attribute.

Image-based testing is now much more flexible. Use the new “Set Image” and “Read Image” nodes to define image variables and apply them in the “Check Image” node and other image-related procedures.

There are many, many more features in QF-Test 10 to explore. You can find all the details in the Release Notes on our website.

Features for integrating the test management tools TMT and Xray as well as support for Oracle Forms are currently under development and will also be included in QF-Test 10 soon with upcoming minor updates.

Events in 2026

QF-Test Basics: Trainings via Webinar

February 23–26, 2026 – in German

March 23–26, 2026 – in English

More about the training courses

4 days, 2 × 2.5 hours each
Effective and rapid knowledge transfer
Small groups up to a maximum of 8 participants
Interaction with the trainers and asking questions are possible at any time

Individual QF-Test Company Training courses

Would you like a training course which is individually tailored to your company? Just send us an email to service@qftest.com.

Ask our service team for a quote

From our YouTube Channel

Going POSTal! Discover WebAPI Testing in QF-Test

QF-Test 10 fundamentally revamps web interface testing, focusing on web APIs such as REST, SOAP, and other web services. In this recording of a special webinar, we introduce you to the new features.

➜ Watch the video now

Scripting in QF-Test (basics)

This video provides an overview of how to use scripts in QF-Test: the SUT script and the server script.

➜ Watch the video now

Dependencies in QF-Test (basics)

This video explains the purposes and intentions of dependencies in QF-Test and shows how simple dependencies are implemented.

➜ Watch the video now

Visit our YouTube channel to subscribe and follow us on LinkedIn.

QF-Test Version 10.0

2025-12-09T00:00:00+01:00

QF-Test 10 introduces powerful enhancements for WebAPI testing.

Create end-to-end HTTP requests, manage authentication, cookies, and proxies through dedicated nodes, and customize workflows to combine UI and API automation in hybrid scenarios.

Accessibility testing has also been significantly improved, with YAML-based configuration and additional checks for keyboard focus visibility and correct usage of the “lang” attribute.

There are many, many more features in QF-Test 10 to explore. You can find all the details in the Release Notes on our website.

QF-Test Version 10.0.1

2025-12-18

This maintenance release fixes startup issues under QF-Test 10.0.0 related to certain license files and addresses several other minor bugs.

QF-Test Version 10.0.2

2026-01-15

QF-Test Version 10.0.3

2026-03-11

This maintenance release adds support for Eclipse/SWT 4.39 alias “2026-03”, updates several libraries and fixes a number of bugs.

QF-Test 10 – WebAPI, AI and more

2025-12-09T00:00:00+01:00

Transcript

Hi there! Today I’m going to show you how you can test web APIs with QF-Test 10. I’ll also walk you through the new AI features in QF-Test, and we have some exciting updates on accessibility testing for web applications in QF-Test 10.

Finally, we’ll take a look at all the other great new features that come with version 10.

QF-Test is the tool for professional UI test automation.

WebAPI

Testing web interfaces has long been possible in QF-Test, but only in a limited way. With QF-Test 10 and its new WebAPI testing capabilities, this test type has become both much more comfortable and significantly more powerful.

You can now send GET, POST, and other HTTP requests directly via the new “Web Request” node. You get full control over every detail of your requests, with freely configurable headers and bodies.

Authentication data can be neatly managed with the new “Request Authentication” node.

Cookies and proxy settings can be configured via the new “Request Options” node.

You can validate API responses by checking the expected status code or use QF-Test’s powerful scripting tools to parse and verify JSON, XML, or any other kind of server response.

For maximum flexibility in designing your tests, QF-Test also provides “Pre-Request Handler” and “Post-Request Handler” nodes, enabling advanced configuration and post-processing of requests and responses.

A comprehensive scripting API lets you model even complex scenarios in a clean and maintainable way.

Unlike other API tools, QF-Test not only offers extensive tools for sending and receiving web requests. You also get access to all of QF-Test’s proven automation and reporting features within WebAPI tests, and QF-Test is excellent for hybrid testing that combines web UI and API interfaces.

AI Integration and the AI Text Check

Version 10 also brings the world of “Artificial Intelligence”- or more precisely, LLMs – into QF-Test. In the new “Check Text with AI” node, you can let an LLM dynamically decide whether a given text is correct or contains errors.

In addition, the new scripting API “ai.ask” lets you communicate with LLMs at any point during test execution to accomplish tasks that were previously cumbersome or impossible.

QF-Test supports integrating various externally hosted LLMs so you can get started right away with your provider of choice. And through our powerful scripting interface, you can connect any LLM provider or API to your tests.

This makes QF-Test 10 ideal for testing chatbots and other UI components with non-deterministic output. It also allows you to check texts for semantic criteria for which no algorithm exists – but for which a good prompt does.

Updated Accessibility (A11y) Checks for Websites

Since QF-Test 9, you’ve been able to check websites for their accessibility. QF-Test 10 now includes additional accessibility tests.

For example, you can now verify the visibility of the keyboard focus on elements.

You can also ensure that your pages use the HTML “lang” attribute correctly.

All of this is configured through our clean, new “Check Accessibility” node and can be tailored exactly to your needs.

Accessibility tests created in QF-Test 9 continue to work normally, but if you’d like to take advantage of the new features, you can easily convert your old procedure calls to the new node using the context menu function “Transform node into”.

The heart of the node is this text input area, where tests are defined interactively in a clean YAML syntax. Multiple tests can be enabled and configured at once.

You can also flexibly exclude known issues or potential false positives from the test report.

New Nodes for Image Handling

Image comparisons have never been the ideal mechanism for UI test automation—but they can certainly be useful. Until now, QF-Test could only generate, process, and compare images through scripting.

With QF-Test 10, image handling becomes dramatically simpler. The new “Set Image” node lets you assign an existing image directly to a QF-Test variable. Likewise, “Fetch Image” allows you to store the image of a specific UI component in a variable.

We’ve also enhanced the familiar “Check Image” node and many procedures in the standard library so that they now accept images from variables. This gives you more flexibility when designing tests, making it much easier to reuse or log images.

Product Editions

Starting with version 10, QF-Test comes in four editions: Pro, Web, Desktop, and Mobile.

QF-Test Pro is the full version with the complete feature set.

If you want to focus on a specific UI technology, you can now use the Web, Desktop, or Mobile editions. These contain only the features needed for the respective application types, making them streamlined and easier to navigate. All new editions remain fully compatible with existing licenses.

Modeless Editing

QF-Test itself becomes easier to use in version 10. We’ve simplified our node editing concept so all invalid fields in your testsuite are now clearly marked, helping you immediately detect and fix issues that might break a test run. And you no longer need to endlessly click “OK” before continuing to edit your test suite.

New Debugger Dialog on Errors

When using QF-Test’s integrated debugger, you now get more detailed feedback when the test run stops due to an error or exception. In this new dialog, you can conveniently choose how to proceed with a single click.

Improved Manual

We’ve further optimized our HTML manual so it’s easier than ever to navigate the wealth of available information. The secondary sidebar lets you jump directly to specific sections of a page without losing context.

You’ll also find the helpful Copy to Clipboard buttons for code snippets not only here but also in our HTML report and directly inside QF-Test.

As always, you can learn more about everything that’s new in QF-Test 10 from the detailed release notes on our website, qftest.com. There, you will also find a download link so you can get started with it right away.

Can I integrate web testing with QF-Test into my CI/CD Pipeline?

2025-11-27T00:00:00+01:00

… common CI/CD systems such as Jenkins and GitLab.

How can QF-Test be integrated into existing test strategies and workflows?

2025-11-27T00:00:00+01:00

… it supports modular test structures and common approaches, such as data-driven or component-driven testing. With clear interfaces and reusable building blocks, the tool fits seamlessly into existing QA workflows. Existing test processes can thus be gradually automated.

What is web testing?

2025-11-27T00:00:00+01:00

… stability, appearance, and behavior across different browsers and devices. The goal is a bug-free, user-friendly, and reliable user experience.

Which browsers and technologies are supported by QF-Test?

2025-11-27T00:00:00+01:00

all major browsers Chrome, Firefox, Edge, and Safari, and is compatible with JavaScript frameworks such as Angular, React, and Vue. Additionally, the tool supports headless testing. You can find an overview at Web Testing.

Why should web testing be automated?

2025-11-27T00:00:00+01:00

For complex or dynamic web applications, automation is significantly more cost-effective in the long run than purely manual testing.

Can UI testing improve the usability of an application?

2025-11-25T00:00:00+01:00

Findings from these tests help optimize user guidance, avoid misunderstandings, and increase overall satisfaction with the application.

How does UI testing contribute to accessibility?

2025-11-25T00:00:00+01:00

This includes screen reader support, correct alternative text, sufficient contrast, and full keyboard navigation. Accessibility testingis essential for both inclusion and compliance with legal requirements.

What is the difference between UI testing and UI testing?

2025-11-25T00:00:00+01:00

While UI testing covers all interactions on the user interface, UI testing focuses exclusively on graphical elements such as buttons, icons, or menus.

What is UI testing?

2025-11-25T00:00:00+01:00

This involves checking whether controls such as buttons, forms, or navigation elements are functioning correctly and whether user interactions are being processed as expected. The goal is to achieve an error-free, consistent, and user-friendly interface.

What methods are available for UI testing?

2025-11-25T00:00:00+01:00

Manual tests are suitable for initial evaluations of new features or exploratory testing, but they are time-consuming. Automated tests are ideal for recurring regression testing and enable frequent, consistent test runs—especially in agile development processes.

When should automated UI testing be used?

2025-11-25T00:00:00+01:00

… especially for frequently recurring test cases, such as regression tests before releases. It enables fast, reproducible results and reduces manual effort—especially in complex or extensive applications.

Why is UI testing so important?

2025-11-25T00:00:00+01:00

Without UI testing, functional errors, unclear feedback, or defective elements often go undetected. Systematic testing increases quality, reduces support costs, and strengthens confidence in the application.

Scripting in QF-Test (basics)

2025-11-14T00:00:00+01:00

Here you will learn about the basics of scripting in QF-Test and get a demonstration for using the SUT script and Server script nodes.

Further information: Scripting in QF-Test (Manual)

Transcript

Welcome to this video about the scripting capabilities of QF-Test.

Today I will give you an overview of how to use scripts in QF-Test.

In addition to event nodes such as mouse clicks or checks and control structures such as loops or if nodes, QF-Test also offers the possibility to integrate arbitrary code snippets implemented in various scripting languages into the test run. Such scripts can greatly extend the functionality of QF-Test.

Script Types

To insert such a script, I select insert control structures from the menu and then Server or SUT script.

Unlike a Server script, an SUT script can interact directly with the system under test and therefore also determine the properties of graphical objects at runtime.
A Server script on the other hand should be used for actions that are independent of the graphical user interface such as database or file operations.

I am now adding an SUT script to my test suite. There are several scripting languages available for implementation. In the current version of QF-Test, there are Jython, Groovy, and JavaScript.

SUT script example

A simple example of an SUT script is the count of rows in a table and then to write this row count to the QF-Test run log. We will now implement the script in the Groovy scripting language:

def table = rc.getComponent("#VehicleTable")
def rows = table.getElementsByClassName("TableRow")
def rowCount = rows.size()
rc.logMessage("Table has " + rowCount + " rows.")

In line one of the script, the table is retrieved from the test application and stored in the variable table.
In line two, the table rows are retrieved into a list
and stored in line three in the variable rowCount with the length of this list.
Line four finally writes this row count to the QF-Test run log.

Pseudo DOM API and accessing native Java component methods

To read the properties of web components, QF-Test offers its own DOM API which is documented in the manual and provides simple methods for accessing DOM properties and HTML elements.

This approach works for every supported technology but the method names may be different because they are technology-dependent. You will find information on this in the respective documentation. For applications with Java Swing, methods can be assessed directly.

When I now run the script, the number of table rows is written to the QF-Test run log, which we can see accordingly.

The QF-Test run context

Let’s go back to the script. You can see in line one and in line four that a variable rc is used there. This stands for the QF-Test run context and offers you options for interacting with QF-Test methods and scripts. In our case, the aim is to identify a graphical component, our table, and write a message to the QF-Test run log.

The run context also allows you to write your custom error messages to the run log or execute entire checks.

The script editor also offers auto-completion for rc. So you type rc., press Control+Space, and now you will see all supported methods and the corresponding documentation.

An example server script

A typical use case for a server script is to write a message or variable content into a file. You can see such a server script here now in the Jython scripting language:

value = rc.getStr("nameOfVehicle")
fh = open ("testfile.txt", 'w')
fh.write("Vehicle is : " + value)
fh.close()

In line one, the QF-Test run context is assessed again and the content of a variable is determined which was previously set somewhere in the test run.

Outlook

Scripts and QF-Test allow you to extend your tests with any logic and simplify some complex tasks. However, scripts and QF-Test can do much more. Scripts allow you to develop so-called Resolvers that optimize QF-Test’s component recognition for your application. Alternatively, you can use a TestRunListener to add additional logic to the test execution. In addition, QF-Test offers many other interfaces which you can learn more about in our detailed manual.

You have now learned the most important basics about scripting support in QF-Test. In the QF-Test Help menu, you will find further links to three available scripting languages and their documentation and tutorials. The QF-Test manual contains several chapters explaining scripts and their possible uses with many examples. Take advantage of this powerful feature to further advance your test automation.

Dependencies in QF-Test (basics)

2025-11-03T00:00:00+01:00

See here why the so called dependencies are useful for your daily work with QF-Test and you’ll learn how to implement them.

Materials for this video

Abridged Transcript

This video covers the basics of QF-Test dependencies. It explains the purpose and intention of dependencies and shows how to implement a simple dependency.

This video does not cover advanced topics such as nested dependencies, characteristic variables, or error handling. Those parts are discussed in other videos.

For the current video, I work in a specially provided test suite, which you can also download from the QF-Test website.

The test suite uses the CarConfigurator provided by QF-Test in the web version as the “system under test” (SUT).

If you would like to work along with me during the video, you will find the suite in the commentary section.
If you would prefer to see the result of this tutorial straight away, you will also find that suite there.

Opening the Test Suite

Now I have opened the dependency test suite I just mentioned. Let’s take a closer look at its implementation.

Here you can see a test suite implemented in a simple way:

This is the Setup node that starts our “system under test” (the CarConfigurator)
Here are some test cases
Finally, a Cleanup node will close our SUT again

In this example, a single test case runs as follows:

First, the application is reset
Then a vehicle is selected
Then a special model is selected
Then further accessories are selected
A discount is set
Finally, the calculated final price is checked

The setup and Cleanup sequences use procedure calls. By double-clicking on a procedure call, I also get to the Procedure node of QF-Test where I can view the existing procedures of this test suite.

The SUT package contains the procedures for starting and stopping our CarConfigurator
The CarConfig package contains procedures needed for the test cases (these are not of interest for the time being)

Running Test Cases

Now that you are more or less familiar with our test suite, I will run test cases from it:

I select the test set and press “Start test run”
QF-Test now works its way through this test suite and executes the test cases with the different discount levels

We wait until the test run is complete.

The test case has run through and we can take a look at the QF-Test run log:

In the details of the run log, we can see that first the setup was run to start the SUT
Then the first test case was executed
Then the application was completely closed with the Cleanup
Then the application was restarted and the next test case was executed

For a complete restart on my system, we need approximately:

28 seconds for the setup
Almost 1 second for the Cleanup work

The whole thing adds up and accounts for a large part of the total test runtime, which we can also see in the performance view.

Particularly with larger applications, constantly stopping and starting the application would be inefficient and does not represent real user behavior.

In our case, this tidying up is actually unnecessary during a normal run of a test case. The SUT has already been started and changes are reset in the test cases anyway.

However, I cannot simply remove the Cleanup node, otherwise the application would still run on the test machine forever after a test run.

In addition, an error in the SUT in an unattended test run could compromise the entire test run instead of just a single test case.

This shows the first disadvantage of the current implementation:

The Cleanup node is executed at the end of every test case

Another disadvantage is that it is not easily possible to start just a single test case.

For example, if a test case had thrown an exception during the last test run (due to an implementation error or a defect in the SUT), I cannot simply execute this test case again
I first have to run the setup to start the application, or create the preconditions manually, which ultimately means executing the setup again

This is still simple in this example, but as soon as test cases become larger and more complex, the entire setup can become tedious.

We can see that we won’t get very far with these means.

Introducing Dependencies

QF-Test dependencies now enter the stage.

Dependencies ensure that the preconditions for a test case are fulfilled, if implemented correctly.

Individual test cases can be executed without manually creating preconditions beforehand
This works even if a completely different test case was previously executed
Dependencies also regulate the Cleanup process and do not carry out unnecessary Cleanup work

Summary:

Dependencies ensure a certain state
Setup and Cleanup nodes only execute a certain sequence

Creating a Simple Dependency

I use the test set from earlier and copy it directly below
Rename the test case, for example, “Tests with dependencies”
Insert a Dependency node:
- Menu: Insert → Dependencies → Dependency
- Right-click: Insert node → Dependency
Name the dependency “SUT started”
Add a Setup node and Cleanup node by dragging the existing nodes into the dependency

Why define the dependency at the test set level?

Each node inherits the dependencies of its parent node by default
In this case, each test case inherits the dependencies of the test set
Defining it at test set level is sufficient as it automatically applies to all contained test cases

Testing the Dependency

Ensure no SUT is running.
Try to start a single test case in the old test set → QF-Test throws a ComponentNotFound exception

Now try the new dependency:

Execute the first test case of the new test set
The test case is executed without any problems, even though the precondition was not fulfilled before the test case started

What happened:

QF-Test first looked at the Dependency when the test case was started
The entry "Required dependency" indicates that the test case requires "SUT started"
QF-Test jumps to the dependency and executes the Setup node
The SUT starts automatically

Full Test Set Execution with Dependency

Close the run log and all clients
Execute the entire test set

Observations:

Execution is much faster than the old test set
The application is not closed between individual test cases
From the run log, we see that no Cleanup node is executed between test cases

Time savings:

Around 30 seconds per test case from the second test case onward
Around 2 seconds on the first test case

How Dependencies Work

Precondition setup sequences are ensured at the beginning of each test case
QF-Test maintains a list of currently valid dependencies (Stored dependencies)
At the beginning of the first test case, the list is empty
When the dependency is executed, QF-Test saves the dependency name in the list
Every new test case compares its required dependency with the stored dependencies
If they match, the Cleanup node is skipped

Setup nodes:

Should start the SUT only if it is not already running
In the example, a Wait for client node checks whether the CarConfigurator client is available
The result is stored in IsSUTRunning
The subsequent If node starts the SUT only if necessary

Advanced Behavior

Another test set demonstrates handling of different dependencies
Required dependencies are compared with stored dependencies
If a stored dependency is no longer needed, QF-Test executes the Cleanup
This allows combining and executing test cases from multiple test sets intelligently

Reusing Dependencies

Dependencies can be copied between test sets, but changes would require updating each copy manually
QF-Test allows storing dependencies in the Procedures section
New test sets or test cases can reference these stored dependencies
The “Dependency reference” node acts as a link to the existing dependency

Conclusion

Dependencies simplify test case execution and precondition management
Setup nodes are executed at the start of each test case
Cleanup nodes are executed only when necessary
Using stored dependencies allows reuse across multiple test sets

In a follow-up video, we will cover nested dependencies and error and exception handling.

Check your own QF-Test test suites to see if dependencies are already used — implementing them is definitely worth it!

Practice instead of theory: Why my dual study program at QFS was the best decision

2025-10-27T00:00:00+01:00

Hello, I’m Marcel Schmied, 23 years old, and I’m from Leipzig.

This fall, I completed my dual study program in computer science at the Cooperative State University of Saxony – in cooperation with Quality First Software GmbH (QFS), which is now part of mgm technology partners.

When I started my studies, QFS was still an independent company. During my very first practical phase, however, the team became part of mgm – which was exciting at first but not a problem at all. The team stayed the same, the environment remained familiar, and the working style just as family-like as before.

A Start with a Summer Party and Team Spirit

Even before my studies officially began, I had the chance to meet the team at the annual summer party – a two-day event with colleagues and their families. This open and welcoming atmosphere made getting started incredibly easy for me.

After that, the classic alternating model began: three months of theory at the university, followed by three months of practical work in the company. While I found the university phases rather dry – lots of lectures, little practical relevance – I looked forward to every single practical phase at QFS all the more.

From QF-Test to Web Development – Learning Through Practice

In my first practical phase, I got to know QF-Test. It enables automated testing of graphical user interfaces – and I was instantly fascinated and impressed by how simple yet powerful the tool is. Writing tests with it was genuinely fun!

In the following phases, I was able to explore many different areas:

Development of a Gradle plugin
Performance testing of Docker environments and VMs
Initial tasks in web development
And even active development on QF-Test itself, for example in the licensing process and improving dialogs.

My personal highlight was my bachelor’s thesis. I focused on continuous integration and deployment – specifically on what’s known as the Bouquet integration, a central component of QFS’s build pipeline. It allows feature branches to be merged dynamically, enabling long-term interaction testing – an exciting and practical approach that still fascinates me.

Schmied, Marcel: Efficient Strategies for Continuous Integration of Long-Term Feature Branches

Small Company, Big Team Spirit

What made QFS special for me was the working atmosphere.

The team was open, helpful, and like a family from the very beginning. I could always ask questions, received honest feedback, and was involved in decision-making. Beyond work, there were many opportunities to get to know colleagues – whether at the Leipzig company run, the table tennis cup, or simply during lunch breaks, where we tried out a new restaurant every week (if one could be found).

Looking Back and Ahead

When I look back on my dual study program today, I’m very grateful for my time at QFS and mgm. I was able to gain insight into nearly all areas of software development, gather practical experience, and discover where my strengths lie.

Now I’m continuing with a master’s degree in data science – to further specialize.

I’m taking with me a wealth of experiences, exciting projects, and wonderful memories – and with that, a big thank you to all my colleagues who accompanied me on this journey.

Going POSTal! Discover WebAPI Testing in QF-Test

2025-10-20T00:00:00+02:00

With QF-Test 10, the testing of web interfaces has been fundamentally revised, with a focus on web APIs such as REST, SOAP and other web services. In this special webinar, we will introduce you to the new functions.

Materials:

QF-Test WebAPI Preview
Demo suite and presentation slides (Requires QF-Test 10 or QF-Test WebAPI Preview)

Summary

With the upcoming QF-Test version 10, web application and web API testing have been fundamentally redesigned. A major focus of this release is on Web APIs such as REST, SOAP, and other web-based services.

Testing APIs differs significantly from traditional UI testing. While QF-Test still supports visual test nodes, script nodes are often needed to simulate realistic workflows. Complex test logic can be wrapped in reusable procedures, making it easy to maintain and scale even sophisticated tests.

After the introduction, Thomas hands over to his colleague Plamen Vesselinov, who presents the new features live in action.

Introduction to Web API Testing

Plamen begins by explaining the difference between UI testing and API testing. Up to now, QF-Test has primarily been used to automate user interfaces — clicking buttons, entering text, and verifying visible changes. In contrast, Web APIs communicate directly via the network, exchanging data through HTTP requests, most commonly in JSON format (though XML and other formats are also supported).

For example: A client application can query a server for user information via an API by providing an ID. The server responds with the requested data. Using a PUT request, this data can then be modified.

Demo: Using the New Web Request Node

Plamen then demonstrates the new Web Request node introduced in QF-Test 10. This node is designed specifically for API testing and allows users to configure and send HTTP requests directly from within QF-Test.

He uses a simple REST service — a sample Pet Store API — to illustrate:

A POST request adds a new pet (“Wolf”) to the store.
A PUT request updates the pet’s name.
A GET request retrieves the updated information.

QF-Test logs each step in detail: the exact request sent, the response received, the status code, and the full JSON content. A status code of 200 indicates success.

QF-Test 10 also introduces syntax highlighting for JSON and XML bodies and supports custom HTTP headers such as Content-Type and Accept.

Pre- and Post-Request Handlers

For more advanced scenarios, QF-Test provides Pre-Request and Post-Request Handlers. These allow users to modify a request before it is sent or process a response after it is received.

Typical use cases include:

Setting authentication credentials
Adjusting request headers
Automatically verifying response content

Handlers are executed in a defined order: Global handlers run first, followed by local handlers defined within the test case itself.

Test Cases, Variables, and Assertions

Next, Plamen presents a complete test suite that adds several pets using different data sets. The suite uses a data driver so that the same test case can be executed multiple times with varying input values.

The Assertion API (rc.check) enables checks and validations without interrupting the test flow if one fails. All results are documented clearly in both the execution log and the HTML report.

QF-Test 10 adds convenient Copy buttons in the report and log views, making it easier to extract large JSON bodies or specific sections for debugging.

Scripting and Technical Background

Under the hood, QF-Test uses the java.net.http package from the Java Development Kit to handle web requests. This means that standard Java methods and classes are directly available within QF-Test scripting environments (e.g., Groovy).

Scripts can be used to:

Loop through data
Dynamically set variables
Parse responses
Implement custom checks

All related classes and objects (Request, Response, rc.web, rc.check, etc.) are documented in detail in the QF-Test manual.

Authentication

QF-Test 10 natively supports several authentication schemes in its Web Request node:

Basic Authentication
Bearer Token Authentication
API Key Authentication

These credentials can be supplied either through HTTP headers or URL parameters. Sensitive information (such as tokens) can be encrypted or hidden from logs and reports.

SOAP Example

In addition to REST APIs, QF-Test also supports SOAP web services. Plamen demonstrates this using a simple Calculator service that adds two numbers. The SOAP request includes an XML body and a SOAPAction header.

If the service responds successfully (status 200), QF-Test displays the result. If not, the system issues a warning rather than failing the test, since the problem is likely with the demo service itself.

Proxy and Certificate Management

QF-Test provides extensive options for:

Proxy configuration (HTTP/S),
Cookie management, and
Certificate handling, including client certificates.

By default, QF-Test accepts all SSL certificates, but this can be customized. There is also a built-in procedure that allows testing Web APIs with client-side certificates.

To observe live network traffic, Plamen recommends using a MITM proxy. Such a proxy can be integrated with QF-Test, allowing users to watch HTTP requests and responses as they happen.

Future Outlook

The QF-Test team is continuously expanding the Web API testing capabilities. Planned features include:

Support for WebSockets,
Additional authentication mechanisms,
Enhanced response validation tools, and
More pre-built procedures within the webapi package.

Conclusion

Thomas Max concludes the session by thanking all participants. The QF-Test team welcomes feedback, questions, and feature requests and encourages attendees to reach out via email after the webinar.

QF-Test Special Webinar about WebAPI Testing

2025-10-15T00:00:00+02:00

Hello dear QF-Test users!

We would like to cordially invite you to our next free QF-Test special webinar on October 20, 2025, at 3:30 PM!

With the upcoming version 10 of QF-Test we are expanding our proven test automation tool with a powerful new feature: support for web API testing.

This means that QF‑Test now offers comprehensive capabilities not only for UI test automation, but also for automated testing of web interfaces (web APIs) thus REST, SOAP, and other web services.

Best wishes,
your QFS team

Upcoming QF-Test special webinar

October 20, 2025, 3:30 PMGoing POSTal! Discover WebAPI Testing in QF-Test

Special webinar in German, October 20, 2025, 10:30 AM

WebAPI early adopters wanted

If you would like to try out the new feature for testing web services and web APIs before QF-Test 10 is released, we are happy to welcome you as early adopter.

Please let us know what is particularly important to you when testing web APIs and which use cases you would like to cover with them.

Get in touch with our service team now

Save the date: Events in 2025

QF-Test Basics: Training via Webinar

November 10–13, 2025in English

More about the training

4 days, 2 × 2,5 hours each
Effective and rapid knowledge transfer
Small groups up to a maximum of 8 participants
Interaction with the trainers and asking questions are possible at any time

Individual QF-Test Company Trainings

Would you like a training course which is individually tailored to your company? Just send us an email to service@qftest.com.

Ask our service team for a quote

From our YouTube Channel

Beyond Strings – how to effectively use object variables in QF-Test 9

This webinar video provides a technical overview of the concept of object variables in QF-Test.

➜ Watch the Video now

Visit our YouTube channel to subscribe and follow us on LinkedIn.

Download QF-Test

Do you already use the latest version of QF-Test?

Download QF-Test 9.0.6

To the Release Notes
Available since 2025-09-10

“Challenge Accepted!” – QFS in Bulgaria

2025-10-13T00:00:00+02:00

Our QF-Test Head of Support Plamen Vesselinov recently attended the “QA Challenge Accepted” and “Dev Challenge Accepted” events in Bulgaria.

The conferences took place for the 11th time, this year at the John Atanasoff Forum in Sofia.

Both events offered exciting insights into current trends and numerous opportunities to network with other professionals from the IT and QA industries.

When asked about his highlights, Plamen said:

I found the discussions and practical tips particularly valuable, which I can now apply directly in my work for QF-Test as a customer support and mentor. The inspiring atmosphere and the many new ideas have further broadened my perspective on our customers’ needs.

QFS at TACON2025 in Leipzig, Germany

2025-10-02T00:00:00+02:00

Two fantastic days at TACON2025 in Leipzig are behind us – and we’re already looking forward to next year!

“TACON” stands for “Testing, Test Automation and Quality Management in Software Development.” For years, TACON has been a central meeting point for testing experts to exchange ideas about current developments and to network.

Thomas Max was there for QF-Test and summarized the time like this:

The keynote by Richard Seidl and the test automation insights from my mgm colleague Lilia Gargouri were real highlights. In addition to many exciting presentations, there were great reunions and new acquaintances. Many thanks to everyone involved and to the summit team for the excellent organization!

Lilia Gargouri’s talk was titled “Success in E2E Test Automation: Key Lessons from a Decade of Experience” and was even awarded “Best Lecture of TACON” by the audience. The presentation was about how mgm technology partners, with the help of QF-Test and other technologies, ensure efficient test automation of projects.

You can learn more about Lilia’s work in this interview on our blog:

From mgm’s coffee kitchen to test automation with QF-Test

Lilia Gargouri is head of the mgm Quality Team together with Martin Varendorff. In this interview, she describes for us how she found her way to QF-Test, what’s important to her in test automation, and about her hopes for the closer cooperation between our companies in the future.

Thomas Max

22/09/2022

QF-Test 9.0.6 available

2025-09-10T00:00:00+02:00

This maintenance release adds support for Eclipse / SWT 4.37 alias “2025-09”, updates a couple of bundled libraries and fixes a few minor bugs.

What QF-Test editions are available, and what are the differences?

2025-08-01T00:00:00+02:00

QF-Test Web for web browsers, accessibility, Electron applications, API and web service testing
QF-Test Desktop for Java and native Windows applications
QF-Test Mobile for Android and iOS apps
QF-Test Pro combines all technologies and additionally supports hybrid applications.

The first three editions focus on the specific UI technologies mentioned above, while QF-Test Pro offers the complete functionality, equivalent to previous QF-Test versions. A detailed overview of features per edition is available on QF-Test Pricing or can be requested from our service team.

Contact Our Service Team

Download QF-Test

QF-Test 9.0.5 available

2025-07-30T00:00:00+02:00

This maintenance release raises the embedded JRE to Temurin 17.0.16, updates some embedded libraries and fixes a few small bugs.

QF-Test 9.0.5 available

2025-07-30T00:00:00+02:00

Hello dear QF-Test users!

What’s new?

Today’s maintenance release QF-Test 9.0.5 raises the embedded JRE to Temurin 17.0.16, updates some embedded libraries and fixes a few small bugs to further improve stability and reliability.

We are currently preparing the next special webinar on a new feature of the upcoming version 10. This time it’s all about testing web interfaces (WebAPIs) such as REST, SOAP and other web services. If you are already interested in advance, please contact us – early adopters are very welcome! Please let us know what is particularly important to you in API testing and which use cases you would like to cover.

The recording of our July special webinar on object variables is now available online. The video shows how to use object variables efficiently in your tests. You will find the link further down in the newsletter.

As always, you can also look forward to the latest training dates, practice-oriented blog articles such as “Scrolling your web application with QF-Test” and helpful video tutorials.

Best wishes,
your QFS team

QF-Test Version 9.0.5

Download QF-Test version 9.0.5
To the Release Notes

Save the date: Events in 2025

QF-Test Basics: Training via Webinar
September 29 – October 2, 2025, German
November 10 – 13, 2025, English
4 days, 2 × 2,5 hours each

Effective and rapid knowledge transfer in small groups up to a maximum of 8 participants
Interaction with the trainers and asking questions are possible at any time

➜ Sign up now

Would you like a training course which is individually tailored to your company? Just send us an email to service@qftest.com.

Special Webinar
Going POSTal! Discover WebAPI Testing in QF-Test
October 20, 2025, 3:30 PM (CEST) (provisional)

With QF-Test 10, the testing of web interfaces is fundamentally revised, with a focus on web APIs such as REST, SOAP and other web services. In this special webinar, we present the new functions.

➜ Sign up for free

Special webinar in German at 10:30 a.m.

Talk at TACON 2025: Erfolg in der E2E-Testautomatisierung
September 23–24, 2025, Leipzig, Germany
Lilia Gargouri, Head of Quality Assurance at mgm technology partners, gives a talk about how to increase the maintainability and stability of their tests through modular test architectures and effective test data management. Participants learn how to minimize volatile tests and apply robust test design principles.

➜ To Tacon

Q12-TMT Test Management Tool
Our parent company mgm technology partners will be represented with Q12-TMT at international and German conferences, events and webinars. As a professional tool for structured test case creation, planning, execution, documentation and reporting, TMT may also be of interest to you as a supplement to QF-Test.

➜ To testing events with mgm in 2025

News

Scrolling on the Web with QF-Test: The complete guide – In this blog post, you`ll get to know all about how to control how QF-Test scrolls your web application and how to control that scrolling yourself.
➜ Go to the blog

From our YouTube Channel

Special webinar video
Beyond Strings – how to effectively use object variables in QF-Test 9
As of QF-Test 9 any objects can be stored in QF-Test variables. In this special webinar we show, how object variables can be used profitably in your tests.
➜ Watch the video now

Visit our YouTube channel to subscribe and follow us on LinkedIn.

Summer Party of QFS and mgm technology partners

2025-07-25T00:00:00+02:00

Together with our parent company mgm technology partners, we enjoyed a wonderful summer party at the Rosengarten in Munich. With delicious food and a relaxed atmosphere, it was a great opportunity to chat, catch up with old contacts, and get to know new colleagues. It was a successful evening that strengthened team spirit and community—we are already looking forward to the next one!

Scrolling on the Web with QF-Test – The complete guide

2025-07-16T00:00:00+02:00

A question that comes up time and again during web application test automation with QF-Test is: How do I scroll? How do I trigger a scroll event? Can I tell QF-Test to turn the mouse wheel? Can I simulate scrolling with the mouse in QF-Test? I just want to scroll down a little!

In general, our first response to these kinds of questions is: You shouldn’t have to. QF-Test handles scrolling by itself and will fully automatically scroll elements into the viewport as soon as it needs to interact with them. That’s why QF-Test does not record scroll events, or offer a ‘Scroll’ node, because in 99% of cases, QF-Test will do the right thing automatically.

But you’re probably here because you’re part of that 1% of cases where that mechanism is not enough. So in this blog post, I will tell you all about how QF-Test scrolls your web application and how to control that scrolling yourself.

Scroll manually using keyboard events

If you just want to scroll a set amount, you should try to scroll by recording keyboard events.

In most web applications, the arrow keys can be used to scroll around. Space and Shift+Space will scroll roughly one window height, and the Home and End keys should scroll to the top and bottom of the document, respectively. That way you might be able to skip the more complicated methods described below.

Fine-tune the QF-Test scrolling algorithm

Let’s say QF-Test is already scrolling for you, but it’s not quite doing it the way you need. QF-Test offers several SUT options you can use to configure its scrolling behavior.

You can set these options in a SUT script node or using the @option doctag in QF-Test 9.

`Options.OPT_WEB_SCROLL_VISIBLE`

This option controls how web nodes are scrolled visible. Possible values are:

Options.VAL_WEB_SCROLL_VISIBLE_DEFAULT (use the QF-Test algorithm),
Options.VAL_WEB_SCROLL_VISIBLE_NEVER (prohibits scrolling),
Options.VAL_WEB_SCROLL_VISIBLE_TOP
Options.VAL_WEB_SCROLL_VISIBLE_BOTTOM
Options.VAL_WEB_SCROLL_VISIBLE_MINIMAL
a custom JSON string matching the options parameter of the Element:scrollIntoView JavaScript API

Options other than “default” and “never” will call node.scrollIntoView() directly in the browser’s JavaScript context. scrollIntoView is a pretty powerful part of the JavaScript Element API. You can learn all about it’s advanced options in the mdn web docs.

You can also override this option on an individual component by setting the node property qfs:scrollvisible:

def node = rc.getComponent("myElement") // replace with a component's QF-Test ID
node.setProperty("qfs:scrollvisible", Options.VAL_WEB_SCROLL_VISIBLE_NEVER)

`Options.OPT_WEB_MIN_DELAY_AFTER_AUTO_SCROLL`

With this option, you can introduce some additional delay after every automatic scroll action, in ms. This is useful if your application uses animations that are triggered by scrolling or if your application just needs a little more time to reload data after scrolling. The default value is 150.

`Options.OPT_PLAY_SCROLL_ITEM`

Set to False to stop QF-Test from automatically scrolling to sub-items of lists, tables or trees. You can use this if QF-Test scrolls to weird places when navigating a tree, for example.

`Options.OPT_PLAY_SCROLL_PADDING`

Extra padding for automatic scrolling, in px. Use this to make QF-Test increase or decrease the calculated minimal required scroll amount so that more of the surroundings of the target element remain visible. The default value is 5.

`Options.OPT_PLAY_WEB_AUTO_SCROLL`

When set to False, QF-Test will not perform any auto-scrolling at all. Use this to completely opt-out of automatic scrolling and handle it manually.

Scroll components into view

You can trigger the QF-Test scrolling algorithm manually in an SUT script like this:

node = rc.getComponent("myElement") // replace with a component's QF-Test ID
// Boolean scrollPointVisible(int targetX, int targetY, boolean propagate)
node.scrollPointVisible(0, 0, true)

This will try to scroll the element so that it becomes visible. If the element cannot be made completely visible, it will scroll it so that at least the requested target point becomes visible.

If the QF-Test algorithm is not helpful in your situation, maybe because you want to trigger a scroll action by itself, you can use a small SUT script which calls any JavaScript scrolling function like this:

node = rc.getComponent("myElement") // replace with a component's QF-Test ID
node.evalJS("_qf_node.scrollIntoView()") // arbitrary JavaScript

Scroll by set amounts

But what if you need even more control over the scrolling or don’t have a particular component you want to scroll to?

You can also any scroll container by a precise amount using JavaScript.

For example, this SUT script would scroll the window down by 25 pixels:

node = rc.getComponent("genericDocument")
node.evalJS("window.scrollBy(0,25)")

The first parameter of the scrollBy method controls the x-axis, so you can even scroll sideways using this method.

And that’s it. That was all you need to know about scrolling web content with QF-Test to get you out of even the trickiest situations.

If you are still stuck, you can get in touch with our support team, who are always happy to help!

Beyond Strings – How To Effectively Use Object Variables In QF-Test 9

2025-07-15T00:00:00+02:00

Slides and Materials

00:00 Intro
02:08 Until QF-Test 8: All variables are Strings
02:50 Automatic Conversion
6:22 Since QF-Test 9: Variables store original object
12:32 Representation in run log and protocol
16:48 Replacement of variable values (expand)
19:08 Simplified access in scripts
22:31 Default values
31:10 Return value in procedures
31:33 Conversion if required
47:16 Additional information
51:30 Usage example: Configuration
56:40 Usage example: Process Parameters

Code examples and summaries

Until QF-Test 8: All variables are Strings

Simple Assignment: Name (String) -> Value (String)

Automatic Conversion

Write:

rc.setGlobal("Numbervalue", 23) // -> Converts into the String "23"
rc.setLocal("Booleanvalue", true) // -> Converts into the "true"
rc.setProperty("Object", new Object()) // -> Converts into the String "java.lang.Object@29f364c"

Read:

rc.getStr(…) // -> returns directly the variable value
rc.getBool(…) // -> Value in ("1","y","yes","true","True",…) ?
rc.getInt(…) // -> Integer.valueOf(Value) / new BigInteger(Value)

Since QF-Test 9: Variables store original object

New Assignment: Name (String) -> VariableData

With:

Value (any Object): .getObject()
String value (String): .toString()
Description (String): .getDescription()

No change “from the outside” during access:

Like before: $(name) and ${group:name}
Like before: rc.getStr(…), rc.getInt(…), rc.getBool(…), …
New: rc.getObj(name) and rc.getObj(group, name)

Representation in run log and protocol

Replacement of variable values (expand)

rc.setLocal('ext', 'TXT')
rc.setLocal('filename', 'qftest.$(ext)')
rc.getStr('filename', expand:true) // -> 'qftest.TXT'
rc.getStr('filename', expand:false) // -> 'qftest.$(ext)'
rc.getStr('filename') // ?
rc.getStr('filename', expand:null) // -> 'qftest.TXT'
rc.setLocal('regexp', Pattern.compile('abc$(ext)'))
rc.getStr('regexp', expand:true) // -> 'abcTXT'
rc.getStr('regexp', expand:false) // -> 'abc$(ext)'
rc.getStr('regexp') // -> 'abc$(ext)' – new!

Simplified access in scripts

obj1 = rc.getObj('varname')
rc.setLocal('answer', 42)
obj2 = rc.getObj('groupname','propname')
dir = rc.getObj('qftest','suite.dir')
xxx = rc.getObj('decrypt','C2094F52F62C0D7953E0CEFF81E269A7')
rc.setProperty('newGroup','newName','newValue')
obj1 = rc.vars.varname
rc.vars.answer = 42
obj2 = rc.groups.groupname['propname'] = rc.groups.groupname.propname
dir = rc.groups.qftest['suite.dir'] = rc.groups.qftest.suite.dir
xxx = rc.groups.decrypt['C2094F52F62C0D7953E0CEFF81E269A7']
rc.groups.newGroup.newName = newValue

Default values

dflt = rc.getObj('default','unknown:Standardvalue')
dflt = rc.groups.default['unknown:Standardvalue']
dflt = rc.withDefault('Standardvalue').vars.unknown
gd = rc.withDefault('Standardvalue').groups.unknowngrp.unknownprop
dflt = rc.withDefault('Standardvalue').getObj('unknown')
gd = rc.withDefault('Standardvalue').getObj('unknowngrp','unknownprop')

Return value in procedures

throw new ReturnException('NeuerValue')

rc.returnValue('NeuerValue')

rc.returnValue(myObject)

value = qf.wrapObject(myObject)
value = qf.wrapObject(myObject,'String value','Description')
rc.returnValue(value)

Conversion if required

Replacements in combinations: -> String – "Today I turn $(age)." – "${qftest:suite.dir}/test.png"
Complete replacement -> Object type is preserved! – "$(data)"
Still automatic: – rc.getInt(…), rc.getNum(…), rc.getStr(…), rc.getBool(…)
Explicitely with the special group “as”: – String expansion: ${as:int:23}, ${as:bool:$(is_available)}

rc.getObj('as','int:23')
rc.getObj('as','bool:$(is_available)')

Valid types:

str, bool, number, object, pattern, int, long, float, double, cmdline, json

Variable exchange QF-Test <-> SUT

QF-Test and the application under test run in different processes
Data exchange via (Java Remote Method Invocation)
Also objects in variables
Must be Serializable
The class definition has to be available in both processes
Works for example with standard classes: – String, Wrappers (Integer, Boolean, …), Pattern, Date – ArrayLists, HashSets (depending in the contents)
Falls back on the “String value” in the other process
In the original process still available as Object (+String)

Additional information

Decrypted flag – Is set automatically if ${decrypt:…} is expanded. – The “description” of the value (e.g. in the run log) is always *** – rc.logMessage(rc.getStr("secret")) still logs the real value! – Is “inherited” during expansion.
AutoExpandable flag – Avoids replacing variables in Strings “by incident” – E.g. in the return value of qfs.utils.readTextFromFile – rc.returnValue(text, autoExpandable:false) – wrapped = qf.wrapObject(text); wrapped.setAutoExpandable(false)
Rerun from run log – Only available for certain (simple) objects

Quality First Software GmbH at the job event on July 11, 2025 – foosball, interviews, and career opportunities

2025-07-14T00:00:00+02:00

Are you looking for an internship, a working student position or a partner for your future dual study program (Bachelor of Science in Computer Science)? Then visit us on July 11, 2025 in Geretsried

Come along and challenge us – foosball with the team of QF-Test is not just about winning, but above all about fun and good conversation! Take the opportunity to get to know us in a relaxed atmosphere, ask questions and find out more about QF-Test and our working environment. We look forward to exchanging ideas with you – at the table and beyond!

Fancy a match at the QFS foosball table?

2025-07-11T00:00:00+02:00

Are you looking for an internship, a working student position or a partner for your future dual study program (Bachelor of Science in Computer Science)? Then visit us on July 11, 2025 in Geretsried

What are the benefits of the new edition model?

2025-07-01T00:00:00+02:00

QF-Test is a product with a wide range of features for testing various UI technologies.

With the introduction of editions, features are now focused on three core areas: Desktop, Web, and Mobile. This makes using QF-Test more simple, clear, and tailored to specific needs.

QF-Test Pro is as an edition that continues to provide the full range of functionality. It combines all technologies and additionally supports hybrid applications.

Download QF-Test

Object variables – free special webinar on July 14, 2025

2025-06-25T00:00:00+02:00

We are pleased to invite you to our next free special webinar:

“Beyond Strings – how to effectively use object variables in QF-Test 9”

Monday, July 14, 2025, 3:30 PM – 4:30 PM CEST

Until now all QF-Test variables contained only strings – if you wanted to store e.g. numbers, they were always converted back and forth.

As of QF-Test 9 any objects can be stored in QF-Test variables. In this special webinar we show, how object variables can be used profitably in your tests.

QF-Test 9.0.4 available

2025-06-11T00:00:00+02:00

This maintenance release adds support for Java 25 as well as for Eclipse / SWT 4.36 alias “2025-06” and fixes a number of bugs.

QF-Test 9.0.4 & QF-Test Special webinar on object variables

2025-06-11T00:00:00+02:00

QF-Test 9.0.4 available, special webinar about object variables

Hello dear QF-Test users!

Today’s maintenance release QF-Test 9.0.4 adds support for Java 25 as well as for Eclipse / SWT 4.36 alias “2025-06” and fixes a number of bugs.

We also cordially invite you to our free special webinar on July 14, 2025 at 3:30 PM. The focus will be on the topic of object variables, which has opened up completely new possibilities beyond strings since QF-Test 9. We look forward to your participation!

In this newsletter, you’ll also find upcoming training dates, hands-on blog articles, and helpful QF-Test videos.

Best wishes,
your QFS team

QF-Test Version 9.0.4

Download QF-Test version 9.0.4
See the new features of QF-Test 9 in our release video Automatically test the accessibility of your web application
To the Release Notes

Save the date: Events in 2025

Special Webinar
Beyond Strings – how to effectively use object variables in QF-Test 9
July 14, 2025, 3:30 PM (CEST)

Until now all QF-Test variables contained only strings – if you wanted to store e.g. numbers, they were always converted back and forth. As of QF-Test 9 any objects can be stored in QF-Test variables. In this special webinar we show, how object variables can be used profitably in your tests.

➜ Sign up for free

Special webinar in German at 10:30 a.m.

QF-Test Basics: Training via Webinar
September 29 – October 2, 2025, German
November 10 – 13, 2025, English
4 days, 2 × 2,5 hours each

Effective and rapid knowledge transfer in small groups up to a maximum of 8 participants
Interaction with the trainers and asking questions are possible at any time

➜ Sign up now

Would you like a training course which is individually tailored to your company? Just send us an email to service@qftest.com.

➜ To Tacon

➜ To testing events with mgm in 2025

News

Maximizing SUT windows – a good idea? Scale windows in QF-Test rather than maximize them – this ensures stable and reproducible tests. If you still need full-screen mode, you can maximize windows with a small script.
➜ Go to the blog
How can I create screenshots of my client application with QF-Test? Screenshots from QF-Test can be saved easily with a simple script. This allows screen recordings to be used specifically for further analysis or documentation purposes – without any detour via the run log.
➜ Go to the blog
What QA engineers say about QF‑Test– “I’ve been automating with QF-Test again for almost 5 months now and it’s a lot of fun. QF-Test is a miracle bag, practically everything can be implemented, stability and performance are unsurpassed. I love it! :-)”
Thank you Walter Hodel, Senior Test Automation Engineer, Product Quality, Xebia Switzerland AG. We love your feedback!

From our YouTube Channel

Special webinar video
Web Accessibility Testing with QF-Test
In this webinar recording we give an introduction to web accessibility and present the new accessibility testing features of QF-Test.
➜ Watch the video now

Visit our YouTube channel to subscribe and follow us on LinkedIn.

Maximizing SUT windows – a good idea?

2025-06-03T00:00:00+02:00

In QF-Test product support we are often asked how to set a QF-Test controlled browser or other SUT windows to fullscreen mode.

It’s better to work with fixed window sizes

In fact, we advise against maximizing windows for the following reason: The maximized window size depends on the system, a fixed window size is the same on every system instead.

QF-Test is comparatively resistant to changes in component coordinates. However, web applications in particular can display completely different page layouts depending on the window size. In the worst case, this can lead to individual components no longer being found.

If the browser is always started with a fixed window size instead, the test behaves uniformly on all computers.

In the preparation sequence that opens the browser, you will find an “Open browser window” node below the “Start SUT if necessary” node, in which you can specify a uniform window size.

How to use fullscreen anyway

If you still want to maximize your browser window, you can use the following Jython server script in QF-Test to maximize all windows containing e.g. “Edge” in the window title under Windows:

import autowin, re

windows = autowin.getAllWindows()
for win in windows:
    title = autowin.getWindowText(win)
    if re.match(".*Edge.*", title):
        autowin.maximizeWindow(win)

You can customize the regular expression ".*Edge.*" to address exactly the window you are interested in with its window title.

Do existing customers need to take action to switch to the new editions?

2025-06-01T00:00:00+02:00

Existing licenses, maintenance, or subscription contracts remain fully valid. Existing customers can continue to use QF-Test Pro as usual within the scope of their current licenses.

For an optimized user experience, simply use the edition that suits you best:

QF-Test Web for web browsers, accessibility, Electron applications, API and web service testing
QF-Test Desktop for Java and native Windows applications
QF-Test Mobile for Android and iOS apps
QF-Test Pro combines all technologies and additionally supports hybrid applications.

Download QF-Test

If you have any questions or customization requests, our service team will be happy to assist you.

Contact Our Service Team

How can I create screenshots of my client application with QF-Test?

2025-05-20T00:00:00+02:00

QF-Test only provides on-board means to write screenshots of a client application to the test run log. This can be done via the “Message” node or the procedure qfs.run-log.screenshots.logScreenshot from the qfs.qft standard library.

Save screenshots to a file

Sometimes you don’t want to store a screenshot in the test run log but use it for other things and store it in a directory first. This is of course also possible with QF-Test, but it requires a script – but just a very small one:

from imagewrapper import ImageWrapper
from java.io import File
screenshot = ImageWrapper(rc).grabImage(rc.getComponent("#Window:"))
screenshot.writeToFile(File(str(rc.groups.qftest.suite.dir) + "/screenshot.png"))

This Jython SUT script uses the exact same mechanism to create screenshots that is used for the test run log.

rc.groups.qftest.suite.dir is a useful shortcut to get the directory of the current test suite. You can of course also call writeToFile() with any other path. "#Window:" is a SmartID and stands for the first window of your application. You can also specify a more specific component here to take a screenshot of a specific part of the application UI.

You can read more about the ImageWrapper class in the QF-Test manual: The ImageWrapper class.

Web Accessibility Testing with QF-Test

2025-05-19T00:00:00+02:00

By June 28, 2025, business websites within the EU must be accessible. But what does accessibility mean in a web context? Who is affected and what do website operators need to be aware of? And above all: How can QF-Test support you in meeting the legal requirements?

In this webinar, we will give a brief introduction to web accessibility and present the new accessibility testing features of QF-Test.

Material: Presentation “Accessibility testing”

Abridged Transcript

Welcome to this special webinar about accessibility testing with QF-Test. My name is Daniel Rieth, a junior software developer at Quality First Software, and my co-moderator, Sofya Leventhal – a fellow software developer – will be keeping an eye on the chat during this event. We are both involved in the accessibility testing project at Quality First Software. Today, I will present the accessibility testing features we’ve implemented.

Agenda

Basics of accessibility and accessibility laws
Overview of QF-Test and its accessibility testing features
Live demo of accessibility testing
Notes and frequently asked questions

What Is Accessibility?

Accessibility is about removing barriers for people with disabilities. Originally discussed in contexts such as public transportation, the focus has shifted to the digital world as more of our activities move online.

Web Accessibility

The W3C (World Wide Web Consortium) defines web accessibility as ensuring that, despite a disability, everyone can perceive, understand, navigate, and interact with the web. There are multiple kinds of disabilities that can affect web interactions:

Visual disabilities: Includes color blindness, low vision, and blindness. Screen readers (integrated into iOS, Windows, Android, or available as third-party programs like Jaws and NVDA) help users interact with digital content.
Hearing disabilities: Users who are hard of hearing or deaf may require subtitles or sign language interpretation for multimedia.
Cognitive disabilities: Poor content structure or unintuitive controls can hinder understanding and navigation.
Physical disabilities: Issues with control movements (e.g., drag-and-drop, pinch-to-zoom) may require simplified interactions.

It is essential for developers to offer text alternatives for graphics and images, provide accessible multimedia content, and ensure that controls are easy to use.

Why Make Websites Accessible?

There are several motivations, including:

Humanistic: Enabling everyone to participate fully.
Economic: Increasing your reach and customer base.
User experience: Accessible websites tend to be more user-friendly and better structured.
Legal compliance: In Europe (and other regions), laws require websites to be accessible to avoid penalties.

Accessibility Laws and Regulations

European Accessibility Act (EAA)

The EAA implements the resolutions of the UN Convention on the Rights of Persons with Disabilities. It mandates that products and services (including online and digital offerings) be accessible. As an EU directive, it is transposed into national laws. For example:

German implementation – BFSG: A law to strengthen accessibility that goes into effect at the end of June. It affects most B2C websites and digital communication tools. Similar laws or guidelines exist in other regions, like the American with Disabilities Act (ADA) in the United States, though the specific requirements may vary.

Web Content Accessibility Guidelines (WCAG)

WCAG provides a set of guidelines to make web content accessible. They are structured around four principles:

Perceivable: Content must be presentable to users in ways they can perceive.
Operable: User interface components and navigation must be operable.
Understandable: Information and operation of the user interface must be understandable.
Robust: Content must be robust enough to be interpreted reliably by various user agents, including assistive technologies.

Each guideline also comes with levels of conformance:

Level A: Minimum accessibility features; without these, some users may find the site unusable.
Level AA: Addresses the biggest and most common barriers.
Level AAA: The highest level, exceeding legal requirements.

Overview of QF-Test

QF-Test provides an automated UI testing solution with multiple ways to simulate user interactions, record sessions, and run extensive test suites. It supports different technologies with a special focus on web applications.

Accessibility Testing Features

To test accessibility using QF-Test, there are two primary approaches:

Integration with an existing accessibility library: We integrated the open-source library axe core, which is developed by experts in web content accessibility guidelines. We enhanced its logging and reporting capabilities to make its results more user-friendly.
QF-Test’s native accessibility checks: We implemented additional procedures for testing aspects like color contrast for graphics—not just text. This allows us to check images (JPEG, PNG, SVG) for proper contrast and verify that alternative texts are provided.

QF-Test version 9.0 (or higher) is required to use these features. You can try these features with a free trial license before committing to a full purchase.

Live Demo Walkthrough

Starting with the Quick Start Wizard

Click the wand icon in QF-Test to open the Quick Start Wizard.
Select the accessibility testing module.
Define the URL of the website to test (in our demo, we use a demo website intentionally filled with accessibility errors).
Choose which accessibility tests to run—either the comprehensive axe tests or specific tests like the color contrast check.

Running an Accessibility Test

1. Setup and execution

The test setup includes a procedure that checks the entire website (or a defined scope) for errors based on selected rules, such as color contrast checks for text.

2. Logging and screenshots

During the test run, QF-Test logs details, takes screenshots of problematic elements, and highlights errors (e.g., elements with a red border indicating contrast issues).

3. Error details

Each error message includes:

The rule ID (e.g., for color contrast or missing alternative text)
An impact rating (ranging from critical to minor)
The faulty element’s identification details (XPath or CSS selector)
A descriptive error message with tips for remediation

4. Remedial actions

For example, one error might indicate that light green text on a white background doesn’t meet contrast requirements (minimum 4.5:1 ratio). Changing the text color from light green to black can resolve the error.

Reporting

QF-Test can generate detailed reports that include screenshots, logs, and all error messages.
These reports provide a quick overview for developers and non-certified QF-Test users, summarizing successful and failed checks.

Advanced Configuration

QF-Test offers extensive configuration options:

Rule exclusions: Skip checks for certain rules if you are confident they are not an issue.
Scope definition: Limit checks to specific parts of a page using a QF-Test ID or a smart selector.
Logging options: Customize how many screenshots are taken and how errors are grouped or reported.

For example, you can configure checks to focus on specific elements (such as icons represented by IMG tags) by defining custom generic classes and adjusting the scope within the test parameters.

Presentation Notes and Closing Remarks

During the live demo, we observed that even if all automatic tests run successfully, it does not guarantee full accessibility compliance. Some guidelines—such as ensuring meaningful titles or alternative texts—require human judgment. While automation can catch up to roughly 75% of issues, manual review remains essential.

Future improvements planned for QF-Test include:

Additional checks for focus visibility when elements are activated.
Extending accessibility testing support beyond web applications to desktop software.

Q&A and Final Thoughts

Thank you for joining this webinar on accessibility testing with QF-Test. We hope that the demonstration and walkthrough have provided valuable insights into how to implement and benefit from these accessibility features.

Happy testing, and let’s make the web accessible for everyone!

QF-Test Special Webinar Web Accessibility

2025-05-13T00:00:00+02:00

QF-Test Special Webinar Web Accessibility

Hello dear QF-Test users!

We would also like to invite you to our next free special webinar on May 19, 2024.

Web Accessibility Testing with QF-Test
May 19, 2025, 3:30 PM (CEST)

By June 28, 2025, business websites within the EU must be accessible. But what does accessibility mean in a web context? Who is affected and what do website operators need to be aware of?
And above all: How can QF-Test support you in meeting the legal requirements?

In this webinar, we will give a brief introduction to web accessibility and present the new accessibility testing features of QF-Test.

➜ Sign up for free

Special webinar in German at 10:30 a.m.

We look forward to your participation!

Best wishes,
your QFS team

Save the date: Events in 2025

Online Expert Day
Toolbox for stable component detection of web applications
May 26, 2025, 2 × 2,5 hours, in German

Following the great success of the previous Expert Days, an English version has now been scheduled. In this online training, we will dive deeply into QF-Test and show you how to optimize the interaction with your web application. With practical exercises on special topics and individual answers to your personal questions, we will ensure that you get the most out of the training. Register now and make your testing processes even more efficient.

➜ Details, pricing and registration

NEW! QF-Test Basics: Training via Webinar
June 23 – 26, 2025, English
June 30 – July 3, 2025, German
4 days, 2 × 2,5 hours each

Effective and rapid knowledge transfer in small groups up to a maximum of 8 participants
Interaction with the trainers and asking questions are possible at any time

➜ Sign up now

“QF-Test is definitively a powerful tool. I think this training will be a game changer in our way to use it and to think our new QF NextGen Framework! Very encouraging. Thank you very much.”

Paul Singuinia, training participant, TotalEnergies One Tech, France

Would you like a training course which is individually tailored to your company? Just send us an email to service@qftest.com.

➜ To testing events with mgm in 2025

From Our YouTube Channel

Feature video – Scripting in QF-Test – Scripting in QF-Test allows you to use the common scripting languages Jython, Groovy and JavaScript to extend your tests with arbitrary logic and simplify some complex test automation tasks. This video gives an overview of the basics of using scripts in QF-Test.
➜ Watch the video now
Feature video – Intelligent test pre- and post-processing: Dependencies can be used to automatically control preconditions and cleanup work for test cases so that they can be executed independently and flexibly – ideal for retriggering only faulty tests or debugging, for example. This video shows how dependencies work and the benefits of the feature.
➜ Watch the video now

Visit our YouTube channel to subscribe and follow us on LinkedIn.

Special webinar: Web Accessibility Testing with QF-Test

2025-05-06T00:00:00+02:00

Free QF-Test special webinar on Monday, May 19, 2025, 3:30 PM – 4:30 PM CEST, in English

By June 28 of this year, business websites within the EU must be accessible. But what does accessibility mean in a web context? What do providers have to pay attention to? And above all: How can QF-Test support you in meeting the legal requirements?

In this webinar, we will give a brief introduction to web accessibility and present the new accessibility testing features of QF-Test.

Fit4Community Sport Challenge 2025

2025-05-01T00:00:00+02:00

With 48 teams and 449 participants from 20 mgm locations we successfully raised 21,000 € for World Bicycle Relief under the banner of #mgmfit4community. For 31 days, participants pushed their limits through sweating, biking, hiking, and running. Together, we have achieved something truly remarkable.

World Bicycle Relief is an international, non-profit organization that specializes in large-scale, comprehensive bicycle distribution programs to aid poverty relief in developing countries around the world. Their programs focus primarily on education, economic development, and health care.

I have purchased existing QF-Test licenses or a previous version of QF-Test 10. What does this mean for me, and which edition should I use in the future?

2025-05-01T00:00:00+02:00

Existing customers do not need to take any action and can continue to use QF-Test Pro as usual within the scope of their current licenses. This edition offers the full functionality of QF-Test versions prior to QF-Test 10.

Depending on the UI technologies being tested, it may be advantageous to use a dedicated edition — QF-Test Web, QF-Test Desktop, or QF-Test Mobile — as they focus on the relevant range of functions.

Depending on the UI technologies you need to test, using another edition — QF-Test Web, QF-Test Desktop, or QF-Test Mobile — may offer advantages, as it focuses features accordingly.

QF-Test Web for web browsers, accessibility, Electron applications, API and web service testing
QF-Test Desktop for Java and native Windows applications
QF-Test Mobile for Android and iOS apps
QF-Test Pro combines all technologies and additionally supports hybrid applications.

Download QF-Test

Our service team is happy to assist you in selecting the edition that best fits your needs.

Contact Our Service Team

QF-Test 9.0.3 available

2025-04-29T00:00:00+02:00

This maintenance release updates the embedded JRE to Temurin 17.0.15 and fixes several bugs.

Maintenance release 9.0.2 available

2025-04-09T00:00:00+02:00

This maintenance release fixes a potential corruption of the system configuration file, improves client connectivity and adds object type support to data drivers. It also comes with some updated libraries and fixes a few bugs.

Maintenance Release QF-Test 9.0.2

2025-04-09T00:00:00+02:00

Maintenance Release QF-Test 9.0.2 available

Hello dear QF-Test users!

We’ve again been busy in the last few weeks: Today`s release QF-Test 9.0.2 fixes a potential corruption of the system configuration file, improves client connectivity and adds object type support to data drivers. It also comes with some updated libraries and fixes a few bugs. QF-Test 9.0.1 improved some of the new features in QF-Test 9, including the manual and screenshots in reports for accessibility testing.

In addition we would also like to invite you to our next special webinar on May 19, 2024. This time it’s all about automated testing for accessibility – we look forward to your participation!

Best wishes,
your QFS team

QF-Test Version 9.0.2

Download QF-Test version 9.0.2
See the new features of QF-Test 9 in our release video Automatically test the accessibility of your web application
To the Release Notes

News

Case study: Testing a complex software solution for social insurance
➜ To the Case study of BITMARCK Software GmbH
QF-Test vs. Tosca – why an IT service provider recommends QF-Test to its customer for testing a Java Swing application.
➜ To the comparison by DVZ GmbH
It’s not magic: How the CustomWebResolver makes your web application UI testable – we are convinced that semantic components and the CustomWebResolver are the best way to create reliable, robust and comprehensive UI tests for web applications.
➜ Go to the blog
Automated web accessibility testing– in his bachelor thesis and in our next special webinar, Daniel Rieth put QF-Test through its paces for the automated testing of web application accessibility.
➜ More about Web Accessibility Testing with QF-Test

Save the date: Events in 2025

Special webinar
Web Accessibility Testing with QF-Test
May 19, 2025, 3:30 PM (CEST)

By June 28 of this year, business websites within the EU must be accessible.
But what does accessibility mean in a web context? What do providers have to pay attention to?
And above all: How can QF-Test support you in meeting the legal requirements?

In this webinar, we will give a brief introduction to web accessibility and present the new accessibility testing features of QF-Test.

➜ Sign up for free

We’ll publish the recording (without the Q&A) afterwards. Special webinar in German: 10:30 a.m.

Online Expert Day
Toolbox for stable component detection of web applications
May 26, 2025, 2 × 2,5 hours, in German

➜ Details, pricing and registration

NEW! QF-Test Basics: Training via Webinar
June 23 – 26, 2025, English
June 30 – July 3, 2025, German
4 days, 2 × 2,5 hours each

Effective and rapid knowledge transfer in small groups up to a maximum of 8 participants
Interaction with the trainers and asking questions are possible at any time

➜ Sign up now

“QF-Test is definitively a powerful tool. I think this training will be a game changer in our way to use it and to think our new QF NextGen Framework! Very encouraging. Thank you very much.”

Paul Singuinia, training participant, TotalEnergies One Tech, France

Would you like a training course which is individually tailored to your company? Just send us an email to service@qftest.com.

➜ To testing events with mgm in 2025

From our YouTube Channel

Release video “Automatically test the accessibility of your web application with QF-Test 9” – In this video we give you a short overview about the new features of QF-Test 9.
➜ Watch the video now

Visit our YouTube channel to subscribe and follow us on LinkedIn.

It’s not magic: How the CustomWebResolver makes your web application UI testable

2025-04-04T00:00:00+02:00

With QF-Test, our goal is to make testing web application UIs as easy as testing a native application. This presents some challenges for which we developed a unique solution we call the CustomWebResolver. In this blog post, I will explain why QF-Test is so much better at testing web applications than other tools and what this “CustomWebResolver” has to do with it.

The problem with CSS and XPath selectors

Most browser-based UI testing tools rely on CSS selectors or XPath to select an element to interact with or validate. This approach has several downsides:

Very verbose: A typical CSS selector looks like this: body > main > div > ul > li:nth-of-type(3) > button.my-action, the same as an XPath would be: .//body/main/div/ul/li[3]/button[@class="my-action"]. Not very readable.
Not very stable: These selectors rely on the underlying HTML structure of the application to remain the same, otherwise they break.
Not easy to auto-generate: This becomes important when recording an interaction. Generating a CSS or XPath selector for an HTML element programmatically is easy. Generating a stable, concise and reusable selector, however, must usually be done by hand.
No Shadow DOM access: It is not possible to use CSS or XPath to select an element encapsulated in a “shadow root”. This is a problem with applications built on the Web Components standard. Instead, JavaScript and a deep understanding of web technologies are required.
Technology-specific: These selectors are only applicable to HTML, they cannot be used in a cross-platform context.
No checking of state: With these selectors, you only found the element. Checking if the element has the required state to pass a test needs to be handled separately.

There is a better way: The QF-Test CustomWebResolver

Although you can also work with selectors here, QF-Test offers a better way: A technology we call the CustomWebResolver, or CWR for short, resolves the raw HTML of your application into a semantic tree of well-defined UI components. This offers several advantages:

No knowledge of HTML required: Test authors are not required to understand the intricacies of the DOM structure of the application to address components.
Semantic tests: UI components can be addressed based on their semantic function as presented to the user, instead their structural position in the DOM or the HTML code.
Unified handling of similar components: UI components that have the same semantic function but are implemented differently on the HTML level are still addressed in the same way.
Checks included: The state of a UI component can automatically be checked according to common criteria like “is it visible”, “what’s the text content?”, “what’s the input value?”, “is it enabled or disabled?”, “is it checked or selected?”, and more.
Don’t worry about the Shadow DOM: With a CustomWebResolver you never have to think about things like shadow roots – QF-Test just takes care of everything.
Robust against DOM changes: The CustomWebResolver is much more resilient against changes to the DOM structure. And if changes are necessary, they can be made in a central place instead of everywhere a component is used.
Cross-platform: Because it is not bound to HTML, the QF-Test component structure can be reused between applications built with Java UI libraries, Native Windows UIs and even iOS and Android apps with little adjustment needed.
Selection via SmartID: In QF-Test you can select a component via the very compact SmartID syntax like this: #List:&2@#Button:

Okay, but how does this magical CustomWebResolver technology work?

The basis of the CustomWebResolver is the translation of the DOM structure into a tree of components of certain generic classes based on a set of mappings. Let’s untangle that statement.

Generic classes

Any application UI consists of a number of widgets, or components, that serve some purpose. There are usually windows with different panels which contain labels, tables, trees, lists, checkboxes, text inputs, sliders, drop-downs, and so on.

QF-Test comes with a big list of generic classes which can be used to describe almost every component imaginable in an application UI. QF-Test understands their semantics, i.e. how they work, and can automatically offer the right actions and checks per component.

For example, QF-Test knows to offer a “‘checked’ state” check for the generic class CheckBox, but not for e.g. the generic class TextField, and it understands that you can click a CheckBox component to toggle it’s ‘checked’ state. It also understands that a Table or List can contain child elements and gives you easy access to them.

CWR mappings

The job of the CustomWebResolver is to look at the DOM of your application and figure out which HTML elements belong to which generic class. To do this, it uses mappings which are usually defined in a YAML document. The simplest mapping possible looks like this:

genericClasses:
- Button: btn

This piece of YAML, when interpreted by the CustomWebResolver, will tell QF-Test to assign every HTML element with the CSS class btn the generic class Button and therefore understand that it’s a button that can be activated as long as it’s not disabled or invisible.

With the CustomWebResolver configured like this, you can now select “OK” buttons using the SmartID #Button:OK, regardless of where this button is or what HTML tag it actually uses, as long as it has the CSS class btn and a label “OK”.

Here is another example of a CustomWebResolver mapping, this time a more complex one:

genericClasses:
- ComboBox:
    attribute: role
    attributeValue: combobox
- List:ComboBoxList:
    tag: ul
    parent: ComboBox
- Item:ComboBoxListItem:
    tag: li
    parent: List:ComboBoxList

The mapping above is for a ComboBox, i.e. some kind of drop-down select input. It actually consists of multiple sub-components:

The drop-down itself,
the list that appears when the drop-down is opened and
the individual selectable options.

Thanks to these mappings, the CustomWebResolver can tell QF-Test to handle this kind of drop-down as a single semantic component: QF-Test can automatically select a given option in the list, it can fetch the current selection or check that a given option is the current selection, or it can return the entire list of available options – all through the QF-Test UI without writing any code or messing with the DOM.

The component tree

Finally, once all relevant components are mapped to generic classes, QF-Test can discard the rest of the HTML and you are left with a beautifully simple tree of semantic components, on which you can build your tests.

And how do I configure this CustomWebResolver for my application?

The only thing users of QF-Test have to do is to provide the initial configuration for the CustomWebResolver. We have implemented three ways to make this as easy as possible:

For a growing list of web component frameworks, we bundle comprehensive CWR configurations with QF-Test. QF-Test will automatically recognize and translate any components from these frameworks into generic classes, ready for you to use in your tests and checks. We support popular frameworks like Vaadin, Angular Material UI, and Google Web Toolkit. Check out the full list to see if your framework is already supported.
If you use a different framework, but your application adheres to the WAI-ARIA standards for web accessibility by marking components with role and aria-* attributes, QF-Test will use these attributes to automatically configure the CustomWebResolver. The better the accessibility of your UI, the better QF-Test will work with it – a double win!
Otherwise, you’ll need to write your own CWR mappings. This is not super-difficult, but it requires some knowledge of the HTML structure of your application. Don’t worry, QF-Test does a lot to help you with this. QF-Test comes with a comprehensive user interface which helps you at every step when editing and verifying your configuration. And with the QF-Test UI Inspector, you can see the effect of your CWR configuration in real-time. And if you’re still having trouble, our support team is ready to assist you.

We believe that semantic components and the CustomWebResolver are the best way to build reliable, robust and comprehensive UI tests for web applications. And our customers think so, too.

If you have been using QF-Test for the web already but have not made full use of the power of the CustomWebResolver yet, you should give it a try. And if you are totally new to QF-Test, you can get started with a free trial today!

The CustomWebResolver in the QF-Test manual: Improving component recognition with a CustomWebResolver
Tutorial for configuring your first CustomWebResolver: Example for “CarConfigurator Web” demo
List of frameworks with built-in CWR: Special support for various web frameworks
Detailed documentation of everything the CWR can do: The Install CustomWebResolver node

Can I upgrade to QF-Test Pro?

2025-04-02T00:00:00+02:00

An upgrade from Desktop, Web or Mobile to QF-Test Pro is always possible – just get in touch with our sales team.

Contact Our Sales Team

Can I expand my existing license?

2025-04-01T00:00:00+02:00

New licenses follow the new edition model and can be combined with existing licenses.

Temporarily, early adopters can expand their licenses under the previous scheme. A direct quote can be requested for this option.

Contact Our Sales Team

Maintenance version 9.0.1 available

2025-03-12T00:00:00+01:00

This maintenance release improves on some of the new features in QF-Test 9 like the manual or screenshots in reports for accessibility tests. It also comes with some updated libraries and fixes a few bugs.

Can I switch editions without losing my configuration?

2025-03-01T00:00:00+01:00

All editions access the same configuration data without modifying any data tied to features of another edition. This ensures a smooth edition switch without issues.

QF-Test

From AI exploration to stable test cases: Best practices for test generation in QF-Test 11

The recommended workflow today (QF-Test 11.0)

Who ya gonna call? Auto-generate procedure calls for clean and maintainable tests

What’s coming in QF-Test 11.1 (later this year)

Reading and editing existing test suites

Best practices for designing your own MCP toolkit with QF-Test

When to turn a procedure into an MCP tool

Granularity: higher-level beats low-level

What not to expose

Writing tool descriptions the AI can actually use

Naming tools: the @mcp/name doctag

Overriding the built-in AI tools

Internal vs. external tools, and permissions

Building your own MCP toolkit

A weekend together in Lichtenfels

Can I completely disable all AI features?

Who ya gonna call? Auto-generate procedure calls for clean and maintainable tests

Transcript

The Problem

How It Works

Procedure Call Definition

Conversion Function

Recording Log

Automatically Recognizing Simple Procedures

Procedure Call Definitions and the Recording Log

More Complex Definitions with Conditions and Placeholders

Automatically Recording Procedure Parameters

The Different Groups

Sequential Group

Choice Group

Unsorted Group

Complex Procedure: “New Winery”

Excluding Mouse Events from the Recording

Ignoring Keyboard Events

Combining Multiple Text Inputs

Describing Nodes in Detail

Using the Recording Log for Debugging

Automatic Procedure Parameters for Complex Recordings

Outlook

Integration with Keyword Driven Testing

Integration with AI

Conclusion

How to run the QF-Test license server as a Windows service

What is a license server and why does it matter for test automation?

Why run the QF-Test license server as a Windows service?

Before you start: Prerequisites

Prepare the QF-Test license server

Set a secure password for the QF-Test license server

Install the QF-Test license server as a Windows service (winsw)

Verify, operate, and maintain the service

Troubleshooting tips for Microsoft Windows environments

No UAC prompt appears

“Script execution is disabled”

Cannot set or change the password

Service starts before networking is available

I prefer a different service wrapper

Practical checklist for QF-Test in Windows-based test automation

QF-Test 11.0.2 available

QF-Test special webinar on September 14, 2026 & security release QF-Test 11.0.2

Next QF-Test special webinar

September 14, 2026, 3:30 PM (CEST) Who ya gonna call? Auto-generate procedure calls for clean and maintainable tests

Download QF-Test

Are you already using the latest version of QF-Test?

Events in 2026

Quality is NOW – Networking Around Quality Engineering, Leipzig, September 15, 2026

QF-Test Basics: training courses via webinar

➡️ September 21–24, 2026 in German

📆 October 5-8, 2026 in English

Individual QF-Test company trainings

QS-Tag November 11-12, 2026

From our YouTube Channel

AI agents in action: autonomous test generation and MCP with QF-Test 11

AI agents in action: autonomous test generation and MCP with QF-Test 11

Materialien

Summary

AI in QF-Test

Connecting AI models

AI test data generation

AI suite generation

Naming tools: the `@mcp/name` doctag

Install the QF-Test license server as a Windows service (`winsw`)