QF-Test

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.

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

AI-driven testing and intelligent test automation for efficient software quality assurance

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:

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 “When tests become intelligent: AI-driven checks with QF-Test”:

[[qf.Preview(videos/2026-03-02-special-webinar-ai-checks)]]

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

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.

Materials

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

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 “When tests become intelligent: AI-driven checks with QF-Test”:

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

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

More about AI-driven testautomation.

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.

Objects in QF-Test variables – an overview

2025-02-20T00:00:00+01:00

When working with variables in QF-Test, the biggest challenge so far has been to understand which variable is currently active with which value. Important here are the variable stacks – the manual explains their function in detail.

The status quo up to QF-Test 9

The values stored in variables used to be strings always. Other objects (e.g. numbers) were converted to a string when stored in a variable with rc.setLocal or rc.setGlobal and stored in the QF-Test main process. When read with rc.getInt or rc.getBool the value was then translated back.

Using this mechanism it is also possible to set a variable in an SUT script and then use its value in a server script or an If node (and vice versa). If you wanted to cache complex objects, you always had to work with the “global” script variables of a scripting language, and across process boundaries you had to use rc.fromSUTand rc.toSUT or rc.fromServer and rc.toServer.

After more than 20 years this simple understanding of values has reached its limits and has been extended with QF-Test 9: it is now possible to store arbitrary objects in QF-Test variables and thus return complex objects from a procedure, for example.

Ensuring backwards compatibility

First things first: We have invested a lot of effort to ensure backwards compatibility. The preexisting access methods in the run context return the same types, values can be stored in the same way and when things get complicated (for example when a non-serializable or very large object from an SUT script wants to be stored in a QF-Test variable), QF-Test falls back to the previously used string representation.

Object variables in variable tables

In QF-Test you can tell right away in any variables table (e.g. in the options dialog or in the debugger window) whether a variable value is a string or has a different type: In the first case, everything looks the same as before, i.e. only the string appears in the table. In the second case, the variable value is preceded by the type of the object in parentheses, e.g. (Boolean) true.

The type of a stored variable can also be changed here via the context menu.

Object variables in “Set variable”, “Return” and parameter tables

In case of the “Set variable” node and the “Return” node in a procedure, the type of the set or returned variable can now also be explicitly specified. This is done at runtime, i.e. when the node is executed, the character string specified as the value in the node is converted into the selected type.

In the same way, the type of the parameter can also be defined in parameter tables, for example in sequences – here too, the conversion takes place when the node is executed. The value of the parameter then appears in the table again with a type reference, for example: (as Number) 3.141. The “as” indicates that the conversion takes place at runtime.

Such a conversion can also be carried out everywhere a variable expansion takes place with the help of the special group “as”, the syntax looks like ${as:fromjson:[1,2,3,4]}.

Object variables via `rc.getObj` and `rc.vars`

The rc.getObj method can now be used to read the object value of a variable in a script or script expression. Analogous to the existing methods such as rc.getStr, rc.getNum or rc.getBool, the variable (with one parameter) or a group variable (property, with two parameters) is evaluated here and its value returned – in this case without conversion.

An expansion of nested variable expressions in the value only takes place automatically if the value is a string, otherwise it must be explicitly requested via the parameter expand=true.

The run context now also offers a practical shortcut to any variable object: instead of rc.getObj("variablename") you can now simply write rc.vars.variablename, and rc.groups.qftest.suite.file returns the File object of the current test suite.

Object variables and `$(name)`

When you use the familiar $ notation for variables, the object value of the variable is used for as long as possible: if the variable average has the value (double) 2.3, for example, the new variable would also have the type double for a “Set variable” node with the default value $(average). However, if you combine the variables with further text, e.g. My average: $(average), the string representation of the variable value is automatically used and the new variable becomes a string, as well.

As before, you cannot simply write $(name) == "John" as a check expression in an If node – the correct syntax would be "$(name)" == "John". But script expressions are preferably used without the $ notation, so it’s better to use rc.getStr("name") == "John" – or now rc.vars.name == "John".

Various small improvements

These changes to the QF-Test variable system also allowed us to integrate other long-awaited features into QF-Test 9: The standard procedures and the special “qftest”-group now return their values as objects, as seen above.

It is now also possible in many places to hide values in variables using the context menu and only evaluate them again at runtime with ${decrypt:...} without the true values appearing in the run log.

Also the “Start process” node now accepts a list object as a parameter, which makes it possible to implement start nodes with a variable number of parameters much more easily.

These are small things, but they all contribute to making working and testing with QF-Test even more comfortable.

Outlook

If you have made it this far, you will have noticed that the topic is complex and certainly cannot be covered exhaustively here.

The developers behind QF-Test will provide details in an upcoming special webinar on the topic of object variables – and the newly redesigned QF-Test manual also explains variables in detail.

QF-Test 9 available

2025-02-20T00:00:00+01:00

The new version QF-Test 9 supports you in the automated testing of your websites or web applications for compliance with established accessibility standards.

We also added object-based variables to QF-Test and completely revised our manual, including navigation and local full-text search. There are many more features to discover like e.g. the revised manual and a new search and filter function in the UI inspector. Download QF-Test 9 now and start testing!

QF-Test 9 now available: Automated accessibility testing of web applications

2025-02-20T00:00:00+01:00

Hello dear QF-Test users!

Making your web content accessible to everyone is no longer optional, but often a must – at least when the German Accessibility Improvement Act (BFSG) comes into force in June 2025. Our new version QF-Test 9 can now support you in the automated testing of your websites or web applications for compliance with established accessibility standards.

We also added object-based variables to QF-Test and completely revised our manual, including navigation and local full-text search. Find out more in the highlights below.

Best wishes,
your QFS team

QF-Test Version 9

Download QF-Test version 9
See the new features in our release video “Automatically test the accessibility of your web application with QF-Test 9”
To the Release Notes

Highlights in QF-Test 9

With QF-Test 9 you can automatically test your websites and web applications for accessibility and take important steps towards compliance with BFSG, WCAG and other standards. In addition to all test modules of the proven axe-core library, we also offer the testing of graphics for required color contrasts. Each test run is complemented by an interactive report containing accurate screenshots and solution proposals.

Our power users will be thrilled about the new object-based variable concept. QF-Test variables are no longer limited to strings – you can now also store lists, UI components, images and arbitrary data structures.
See also our latest blog about Objects in QF-Test variables.

Our HTML manual has been completely revised for QF-Test 9. With its integrated navigation and lightning-fast full-text search, you always keep an overview – now also in dark mode.

The UI inspector, our powerful tool for understanding QF-Test’s live view of your application, now has search and filter function so you won’t get lost even in deeply nested hierarchies.

There are many more features to discover in QF-Test 9 such as an ”@option”-Doctag. All details can be found in the Release Notes. Please also take a look at the notes on possibly incompatible changes.

Save the date: Events in 2025

QF-Test Basics: Training via Webinar
March 17-20, 2025, German
March 24-27, 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.

Free 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 now for free special webinar

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 h, in German

➜Details, pricing and registration

News

Accessibility testing for web applications: The online magazine “Informatik Aktuell” has published an interesting article on the topic of accessibility with several approaches and considerations. QF-Test will also provide accessibility tests for websites from the next version.
➜To the German article on Informatik-aktuell.de
Accessibility testing: QF-Test compared to other tools – Tobias Kirsch, Senior Software Engineer at Adesso evaluates QF-Test beta test developer version with a11y checks.
➜Go to the German blog from Adesso
From a simple email to a memorable internship – “This feeling of being ready and useful very quickly was extremely satisfying and gave me a lot of motivation” Find out more about Maxime’s internship at QFS.
➜Go to the blog

From our YouTube Channel

Special webinar “Efficient end-to-end test automation with QF-Test”: In this recording, Lilia Gargouri shows how QF-Test has been used at mgm technology partners for over ten years – across five different UI technologies and ten locations, in a mixed team of developers, QA analysts and business analysts – and how it has saved them thousands of hours of manual testing.
➜ Watch the video now

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

QF-Test Version 9.0

2025-02-20T00:00:00+01:00

based on the proven axe-core library but including additional features like testing the color contrast of graphical elements and a highly informative visual Report.

QF-Test power users will be thrilled that variables are no longer limited to strings. You can now also store lists, UI components, images and arbitrary data structures.

Detailed Release Notes QF-Test Version 9.0

Highlights in QF-Test 9

More Information

Our power users will be thrilled about the new object-based variable concept. QF-Test variables are no longer limited to strings – you can now also store lists, UI components, images and arbitrary data structures. See also our latest blog about Objects in QF-Test variables.

More Information

Our HTML manual has been completely revised for QF-Test 9. With its integrated navigation and lightning-fast full-text search, you always keep an overview – now also in dark mode.

More Information

The UI inspector, our powerful tool for understanding QF-Test’s live view of your application, now has search and filter function so you won’t get lost even in deeply nested hierarchies.

More Information

There are many more features to discover in QF-Test 9 such as an “@option” doctag. All details can be found in the Release Notes. Please also take a look at the notes on possibly incompatible changes.

QF-Test Version 9.0.1

2025-03-12

QF-Test Version 9.0.2

2025-04-09

QF-Test Version 9.0.3

2025-04-29

This maintenance release updates the embedded JRE to Temurin 17.0.15 and fixes several bugs.

QF-Test Version 9.0.4

2025-06-11

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 Version 9.0.5

2025-07-30

This maintenance release raises the embedded JRE to Temurin 17.0.16, updates some embedded libraries and fixes a few small bugs.

QF-Test Version 9.0.6

2025-09-10

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.

Automatically test the accessibility of your web application with QF-Test 9

2025-02-20T00:00:00+01:00

In this video we show you how you can use QF-Test 9 to test the accessibility of your website or web application. It’s quick and almost completely automatic! We will also demonstrate some of the other abilities QF-Test has gained with version 9.

QF-Test 9 introduces accessibility testing for web applications to ensure compliance with WCAG and other standards, based on the proven axe-core library but including additional features like testing the color contrast of graphical elements and a highly informative visual report. QF-Test power users will be thrilled that variables are no longer limited to strings. You can now also store lists, UI components, images and arbitrary other data structures.

Transcript

Hi! In this video we will show you how you can use QF-Test 9 to test the accessibility of your website or web application. It’s quick and almost completely automatic! Also, we will demonstrate some of the other abilities QF-Test has gained with version 9. QF-Test is the tool for professional UI test automation.

In terms of accessibility, a lot has changed with QF-Test 9. Firstly, we have significantly improved the usability and accessibility of QF-Test itself: Using QF-Test with a screen reader or just a keyboard works much better now than before.

Secondly, QF-Test can now assist you with making your own applications more accessible. Version 9 introduces a whole new suite of accessibilty checks. With them, you can fully automatically test your web application for conformity to WCAG (“wee-cag”/”double-u c a g”), the Web Content Accessibility Guidelines – an important step towards compliance with the European Accessibility Act and other laws.

As always with QF-Test, it could not be easier to get started with the new accessibility testing tools.

Every good test in QF-Test starts with the Quickstart Wizard. In here you will find a new entry for our accessiblity tests.

Basically, we only need to enter a URL and off we go. Using QF-Test 9, you can test the accessiblity of any website or web application.

In the next step, you can optionally define exactly which checks QF-Test should perform. QF-Test version 9 can run every check included with the well-known and trusted open-source library “axe-core”. In addition, we offer color contrasts checks of graphics. Our goal is to introduce support for more aspects of accessiblity testing in future versions of QF-Test.

But for now, wo don’t need to do anything else. With one click, QF-Test now launches a browser and thoroughly puts our app through its paces.

The best part of this feature, however, is the reporting built into QF-Test. For every test run, QF-Test generates a comprehensive technical run log.

In addition, there’s a clear and interactive HTML report. It visualizes which elements of your application failed which checks using lots of screenshots. It also offers tips on how to fix many of these issues.

On the occasion of this update, we also upgraded the HTML report. Next to some visual upgrades, it now offers a dark mode, same as QF-Test itself. We also greatly improved the navigation through screenshots and messages.

QF-Test 9 also includes a new example test suite which you can use as inspiration for your own tests. It’s the only sample suite in QF-Test which will generate errors when run. But don’t worry: In this case, this is on purpose - so you can get a realistic impression of what a typical QF-Test accessiblity report looks like.

As with all features, you can find detailed information about everything new in QF-Test in the included manual. And in this version, we have completely overhauled the HTML manual.

It now includes an intuitive navigation sidebar, so you always know where you are in the manual.

We also added a lightning-fast search engine to the manual. Using it, you can effortlessly find what ever you are looking for – even without an internet connection.

The new manual is much more readable and more informative. And most importantly, it also includes a cool dark mode.

One chapter of the manual that has gotten especially interesting in QF-Test 9 is the one on “Variables”. With this update, we have extended our variable system by object variables. Now, you can no longer just store strings in QF-Test variables, but lists, UI components, images and any other data structure you want.

This addition makes QF-Test more powerful than ever. For example, object variables allow you to define a variable as encrypted and keep it encrypted throughout your whole suite, and it’s true value will never be logged.

In many places in QF-Test, you can now choose a desired object type when defining a variable. And many procedures across the qfs.qft standard library will now optionally return objects.

We also developed powerful new scripting APIs such as “rc.vars”. With “rc.vars”, it becomes incredibly intutive to read and write QF-Test variables.

And of course, all of these additions are backwards-compatible. Your existing tests will perform exactly as before and you only have to dive into this topic once you are ready for it. But we are confident that especially our power users will quickly learn to use the new object variables in QF-Test 9 to great effect.

Our UI inspector is still the best tool to keep tabs on how QF-Test sees your application in real-time. With QF-Test 9, we have enhanced the UI inspector with a search and filter function.

Using it, you can get a better overview about which component classes show up where in your application. Especially with more complicated component hierarchies, this feature can be invaluable.

Another very neat little addition to QF-Test 9 is the ability to set options only for the scope of a specific node.

Often, you only need an option for a brief moment to override an otherwise useful default behavior of QF-Test. Thanks to the new “option” doctag, you can now summarize the annoying “set option”, “perform action”, “reset option” steps into one action.

You can not only set the doctag on individual nodes, you can also set it on an entire test step - or any other sequence. The option will then apply for all nodes that are part of that sequence.

And that’s not even everything that’s new in QF-Test 9. There are a ton of smaller improvements and features. Visit our website and take a look at the full release notes to learn about all the details.

Not convinced yet? Try QF-Test 9 for yourself today! You can download QF-Test for free at www.qftest.com and start testing right away.

From a simple email to a memorable internship

2025-02-10T00:00:00+01:00

In my 21 years, I never left France before. And suddenly, I am driving a thousand kilometers to live in Germany for three months. How did this happen?

Soon after I began working with QF-Test at Thales, and since I am the only person on my team working with this software, I decided that it might be fun to learn more about QF-Test directly next to the people who built it. So, I sent an email, and a few days later, I got an interview with QFS.

It only took a week or two to get a definitive answer, and I left for Germany on the 30th of July. Of course – because I like stupid challenges – I decided to drive to Leipzig, from Paris, on my motorcycle. 14 hours of riding later, through rain and sunshine, I finally arrived in Leipzig. Two days later, I started working.

Working at QFS was a really enriching and weird (in a good way) experience. The work culture is completely different from what I am used to, whether it’d be at Thales or other smaller companies. Coffee break? 3 minutes. 3 minutes!? Fastest I ever managed was 10! Maybe we are a bit too much into coffee in France. Or is it just an excuse not to work? I’ll let you decide. Same goes for the lunch break. If we go out in France, at a restaurant, it’ll be for at least an hour and a half. In Germany, 30 minutes is all you need. These are only small things, but it shocked me how much we love not to work during working hours in France.

About the actual work: I have never seen such a good cohesion in a team as at QFS. Communication was smooth, not too many meeting, so we actually had time to work. And the team is awesome. Found a bug? Have an issue? A question? Just ask or talk about it, and you’ll get the answer, or the bug fixed. And even as an intern, a new person working at the company, the onboarding was pretty smooth. Everything is done logically and is easily understandable. It didn’t take me more than a week to understand most of my job and start working. This feeling of being ready and useful very quickly was extremely satisfying and gave me a lot of motivation to perform my tasks.

The tasks were satisfying as well. To be given a task, some time, and some liberties to do it, without having a strict deadline, is really comfortable. And when it is done, and everybody is happy about it, it feels even better. I don’t have the words to explain it better, but trust me, it was a pleasure working at QFS.

This internship also allowed me to visit and live in a foreign country. As a first timer, this was a bit difficult. Going to Aldi, the barber, or the bakery for the first time felt like I had never done it before. But in the end, it is just like everywhere else. It is not that hard. I also got to visit the countryside, and I even made a rider friend along the way. I got to ride very fast, to see incredible landscapes (The Zugspitze with Gregor and Tina!), towns, to feel the german weather (not the best…) and to meet new people.

Even though I loved my stay in Germany, going back to France was a relief. I got my habits back, my birds, my cars, my gym, everything. But I would go back to Germany if given the opportunity, no doubt.

In conclusion: QFS is an amazing company, leaded by amazing people, and I understand why it is considered such a great place to work. I learned a lot, and am ready to get QF-Test operational at Thales very soon, as well as making it more widely used across our different teams.

Accessibility testing for web applications: Three approaches and additional considerations

2025-02-06T00:00:00+01:00

The online magazine “Informatik Aktuell” has published an article on “Accessibility testing for web applications: Three approaches and additional considerations”. QF-Test will also provide accessibility tests for websites from the next version.

How does QF-Test handle mixed testing environments (e.g., Desktop and Web applications)?

2025-02-01T00:00:00+01:00

… all technologies and features and additionally supports hybrid applications. This allows you to combine tests for Desktop, Web, and Mobile applications flexibly. Our service team can advise on the best solution for your project.

Contact Our Service Team

Download QF-Test

Where can I report a bug in QF-Test

2025-01-24T00:00:00+01:00

Send us a description of the issue via email to support@qftest.com and we will have a look. Please make sure to provide as much information as possible, especially test suites and run logs.

How can I suggest features (Feature requests) for QF-Test?

2025-01-23T00:00:00+01:00

Please send your ideas and wishes to support@qftest.com.

Are there any free offerings?

2025-01-22T00:00:00+01:00

What about consulting for QF-Test?

2025-01-21T00:00:00+01:00

What about training for QF-Test?

2025-01-20T00:00:00+01:00

Where can I get help troubleshooting?

2025-01-19T00:00:00+01:00

Additional information can be found in the technical FAQ.
Get started: For when you’re having trouble installing and licensing QF-Test.
Interactive tutorial: For getting started with QF-Test quickly (especially note the chapter Getting help).
Manual: All further questions should be answered by our comprehensive manual.
Context sensitive help: click the right mouse button on pretty much any part of the QF-Test UI and select “What’s this?” to jump to the corresponding manual page.
Videos: Check out our growing library of videos about various subjects for beginners and advanced users.
Blog: We sometimes share helpful tips and tricks for using QF-Test on our blog.
Free email support: During your evaluation period of QF-Test we grant free support. This channel, including guaranteed response time, is also available to customers with a maintenance contract.

I have received a license file as attachment of an email. What shall I do with it?

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

“license”, “license.new”, “license.txt”, “license.dat”, “license.old”, “license.server” … Who’s gonna know about that?

What is the best way to get started with QF-Test?

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

Get started with QF-Test

QF-Test special webinar “Efficient end-to-end test automation” on Feb. 3, 2025

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

We are starting the new year with an invitation to our exciting new special webinar by Lilia Gargouri, a proven expert in quality assurance and test automation and soon to be a member of the German Testing Board.

QF-Test special webinar “Efficient end-to-end test automation” on Feb. 3, 2025

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

Hello dear QF-Test users!

How can we achieve higher quality with less effort?
This is the core question of Lilia Gargouri, Head of Quality Assurance at mgm technology partners.
In this webinar, she shows how QF-Test has been used for over ten years in currently 22 projects at mgm – with five different UI technologies and across ten locations, in a mixed team of developers, QA analysts and business analysts – and how it saves them thousands of hours of manual testing.
➜Sign up now

Best wishes and a good start in 2025,
your QFS team

Save the date: Events in 2025

QF-Test Basics: Training via Webinar
March 10-13, 2025, German
March 24-27, 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.

Online Expert Day
Toolbox for stable component detection of web applications
May 26, 2025, 2 × 2,5 h, in German

➜Details, pricing and registration

News

Introduction to QF-Test Plugin Development – We show you step by step using an example how to customize QF-Test to your needs to make your testing process more efficient.
➜Go to the blog
Extending the QF-Test Assertion API – A practical introduction.
➜Go to the blog

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

And where do I get this license file?

2025-01-15T00:00:00+01:00

Request it using the trial request form. With this license you can evaluate QF-Test for your application without restrictions.

Extending the QF-Test Assertion API – A practical introduction

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

Since QF-Test 9 there is a new and comfortable way to check conditions in scripts: The QF-Test Assertion API, which is loosely based on the chai.JS library known from Javascript.

In a Groovy script, for example, we can now write:

def foo = 'bar'  
def beverages = [ tea: [ 'chai', 'matcha', 'oolong' ] ]  

expect(foo).to.be.a('String')  
foo.should.be.equal('bar')  
expect(foo).to.have.lengthOf(3)  
expect(beverages).to.have.property('tea').with.lengthOf(3)

The API of the fluid check expressions is well equipped so that most checks can be written very easily. In some special cases, however, you may wish to extend the API, as is possible with chai.JS plugins. For example, it would be nice if you could use the following expression to check whether a given string represents a valid JSON object:

def validJson = '[1,2,3,"s",{}"key":"value"}]'
def invalidJson = '[{]'

validJson.should.be.json()
invalidJson.should.not.be.json()

QF-Test offers an interface for such extensions of the Assertions API as well, which we would like to demonstrate in this blog post.

To enable a dynamic extension of the API, a proxy object is created under the hood for each assertion whenever a test expression is executed. In addition to the standard methods of each assertion, this proxy also supports any methods that have been registered as extensions in the meantime. An interface definition in the form of an interface is first required for these extensions:

package de.qfs.lib.assertions.external;

import de.qfs.lib.assertions.Assertion;

public interface JsonAssertion extends Assertion {
    Assertion json();
}

Please note that

the interface is normally placed in the en.qfs.lib.assertions.external package,
it extends the existing Assertion interface,
and that each new API method in turn returns the assertion object itself.

This makes it possible to chain the method calls. The code to be executed can now be defined in a separate class that implements the interface and derives it from en.qfs.lib.assertions.AssertionExtension. However, it is easier to do this directly in the interface definition as a default implementation:

default Assertion json() {  
    return self();  
}

The implementation of the method does not yet do very much, it merely returns a reference to its own assertion object, as required. To perform or report the actual check, the inherited method doAssert(condition, message, negatedMessage, expected, actual) must be called:

condition is a boolean value or a function with a boolean return value that contains or returns the result of the check.
message is a string that can be used for an error message or for the check performed in QF-Test – the placeholder #{this} is replaced by the checked object, #{exp} by the expected value and #{act} by the actual value (usually identical to the checked object).
negatedMessage contains the message that is used for checks whose call chain contains a not.
expected contains the expected value.
actual contains the actual value.

With the exception of condition, all parameters are optional and can be omitted at the end of the parameter list.

Our assertion method might now look like this:

default Assertion json() {  
    doAssert(this::isObjectJson,  
            "expected #{this} to be a json string",  
            "expected #{this} not to be json string");  

    return self();  
}

We have outsourced the actual check to a separate method in which we try to read the input as JSON and return true if successful and false if an error occurs:

default boolean isObjectJson() {  
    try {  
        final Object s = _obj();
        if (s instanceof String) {  
            Json.parse((String) s);  
            return true;  
        }  
        return false;  
    } catch (final ParseException ex) {  
        return false;  
    }  
}

Note that the expression _obj() was used to access the object to be checked.

In order to be able to use our new method in check expressions, it must be registered once with the AssertionFactory. This factory is a singleton and provides the instance method registerExtension(extension, overwrite) for this purpose:

extension is the new assertion interface of the extension. Either a class that implements the interface or an object of such a class can be specified here.
overwrite determines how to proceed with already registered methods of the same name. If true, the method of the newly registered extension is preferred, with false the previously registered one is.

The easiest way to register an extension is to do so when initializing a QF-Test plugin. A general description of how to build QF-Test plugins can be found in the previous blog article. For the plugin that provides our Assertion API extension, the corresponding plugin class could look like this:

import de.qfs.apps.qftest.shared.QFTestPlugin;  
import de.qfs.lib.assertions.AssertionFactory;  
import de.qfs.lib.assertions.external.JsonAssertion;  

public class JsonAssertionPlugin implements QFTestPlugin {  

    @Override  
    public void init()  
    {  
        AssertionFactory.instance()
                    .registerExtension(JsonAssertion.class, false);  
    }  
}

If you want to add “properties” to the call chain, please note that the associated methods must each be preceded by a get – the script engines Jython or Groovy then automatically convert the properties in the check expression into the corresponding method call.

As an example, we want to extend our new API to include the check for “primitive” JSON objects:

def primitiveObj = '"String"'
def nonPrimitiveObj = '[1,2,3]'

primitiveObj.should.be.primitive.json()
nonPrimitiveObj.should.not.be.primitive.json()

Then we add the corresponding getPrimitive method to our JsonAssertion interface:

default Assertion getPrimitive() {  
    self().flag("primitive", true);  
    return self();  
}

and add the test method:

default boolean isObjectJson() {    
    final boolean primitive = AssertionUtil.flagAsBoolean(self(), "primitive");

    try {  
        final Object s = _obj();
        if (s instanceof String) {
            final JsonValue value = Json.parse((String) s);  

            if (primitive) {  
                final boolean valueIsObjectOrArray = 
                                  value.isObject() || value.isArray();  
                return ! valueIsObjectOrArray;  
            }  

            return true;  
        }  
        return false;  
    } catch (final ParseException ex) {  
        return false;  
    }  
}

A typical Assertion API scheme is used here: in the property method, a status value is set in the assertion object with self().flag(name, value), which is then retrieved during evaluation. To achieve this, the self().flag(name) method returns the corresponding status value. To simplify matters, the class en.qfs.lib.assertions.AssertionUtil offers the static helper methods flagAsBoolean(assertion, name) and flagAsString(assertion, name).

The message for the error case should also be adjusted to reflect the status:

default Assertion json() {  

    final boolean primitive = AssertionUtil.flagAsBoolean(self(), "primitive");  
    final String descriptor = primitive ? "primitive " : "";  

    doAssert(this::isObjectJson,  
            "expected #{this} to be a " + descriptor + "json string",  
            "expected #{this} not to be " + descriptor + "json string");  

    return self();  
}

Finally, in order to hide the internal details in the stack trace of the AssertionError thrown in the event of an error, the test method can define itself as an entry point (ssfi stands for start stack function indicator)):

default Assertion json() { 
    _ssfi(JsonAssertion.class,"json");

    (...)
}

Note: Due to the class loader used, extensions are currently restricted to Server scripts and Groovy SUT scripts.

The code of the entire extension is available on GitLab.

Is a trial version available for download?

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

Get QF-Test on our Download page. You can start your application with QF-Test and get a first impression of the tool and to check out the tutorials. To save your work you’ll need a license.

My boss doesn’t want to spend any money! What can I tell him/her?

2025-01-13T00:00:00+01:00

Just compare the cost of QF-Test licenses with the cost of developers’ or testers’ wages and the cost of bugs detected after release – not to mention the damage to your company’s reputation.

If your boss is still on the fence, you can send them a link to our page Benefits for decision-makers.

What’s the point of test automation?

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

Comprehensive automated tests, executed regularly during software development, will help to find bugs at an early stage. The reproducible security achieved this way ensures higher quality and shorter time to market at lower maintenance expense.

I already do unit testing, why is that not enough?

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

UI-based testing exercises an application as a whole, because a working steering wheel and motor in isolation (unit tests) don’t guarantee roadworthiness. For more, see our page Benefits for developers.

What are SmartIDs?

2025-01-10T00:00:00+01:00

Instead of recording a component and referencing it via its “QF-Test ID”, with a SmartID you can reference the UI element directy by its properties. For example, the SmartID Button:label=OK references a button with the label “OK”.

Thanks to this technology it becomes possible to reference components much more precisely and intuitively, regardless of the SUT.

SmartID – The next generation of component recognition

We are always working on improving component recognition in QF-Test. With QF-Test 6.0 we introduced a completely new paradigm: SmartID

Max Melzer

16/12/2022

Introduction to QF-Test Plugin Development

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

Some people may have stumbled over the plugin directory in QF-Test and wondered why it is there and how to use it. In fact, the directory (with its subdirectories qftest and sut) serves multiple purposes:

Upfront, if you place any .jar file containing Java classes in that directory, they will be automatically added to the QF-Test and/or SUT classpath and therefore available for use in server or SUT script nodes, in data driver nodes (e.g. JDBC drivers) etc. If the library is placed in the qftest subdirectory, the contained classes are only available within the main QF-Test process and server scripts, but not within the classpath of the tested application. If you place the library in sut, you can use it within SUT scripts only. A library placed directly in plugin is available in both context.

In addition, it is possible to enhance the QF-Test test execution itself, or to add special functionality. Unforgotten is the holistic plugin, which caused QF-Test to play “characteristic” sounds during test execution so users could listen to their tests running. While this example may be rather playful, we will see how to use this mechanism for more serious tasks.

With QF-Test 8 and the QF-Test Grade plugin 2.1.0 we made the development of QF-Test plugins very comfortable – it’s time to take a deep dive into the topic.

In this example, we will build add a plugin which extends QF-Test with an embedded web server that displays the current execution state. The final result can be found at gitlab.com/qfs/qftest-plugins/webstatus-plugin.

Technically, QF-Test plugins are also .jar files which are placed in the plugin folder. But they contain a specific pointer file in META-INF/services which allows QF-Test to load the plugin class at runtime.

For development, any IDE which supports Gradle builds can be used, for example IntelliJ. To follow along, create a new project, name it webstatus, select Gradle as build system and make sure that at least Java 17 is selected as JDK.

As a first step, we add the QF-Test Gradle plugin to the project by adding it to the plugins section of the build.gradle file:

plugins {  
    id 'java'  
    id 'de.qfs.qftest' version '2.1.0'
}

If we now reload the project (e.g. using the reload button in the “Gradle” IntelliJ panel), Gradle will automatically download the latest QF-Test and add it to the project’s testImplementation dependencies.

You can instruct the plugin to use the QF-Test installation you already have on your system by adding the version = 'local' property in a new qftest section of the build.gradle file (If you did not install QF-Test at the default location, you can use the versionDir property instead, as described in the documentation of the QF-Test Gradle Plugin):

qftest {  
    version = 'local'  
}

Until now, the instructions have been similar to any project which uses the QF-Test Gradle plugin for test execution. To put the project into “QF-Test plugin development mode”, we need to add another property to the qftest section of build.gradle:

qftest {  
    version = 'local'  
    pluginClass = 'de.qfs.apps.qftest.plugins.WebStatusPlugin'  
}

In our example de.qfs.apps.qftest.plugins.WebStatusPlugin is the fully qualified class name of the plugin class we’re about to develop. Since the QF-Test plugin will only be available in the QF-Test main process, we can tell the Gradle plugin to focus on this development environment:

qftest {  
    version = 'local'  
    pluginClass = 'de.qfs.apps.qftest.plugins.WebStatusPlugin'
    devScopes = ['qftest']  // default: ['qftest','sut']
}

After having setup the build system, we can start developing the plugin itself: Let’s create a new class and let it implement de.qfs.apps.qftest.shared.QFTestPlugin:

Since the Gradle plugin automatically extended the implementation dependencies, the required QF-Test classes are directly available using code completion. As a first step, we simply add a “Hello World” output:

@Override
public void init() {  
    System.out.println("Hello plugin world!");  
}

To start up QF-Test including the plugin, we can use the startQFTest task of Gradle – the Gradle Plugin will automatically take care of creating the required services file and make the new class available to QF-Test:

 % ./gradlew startQFTest
Starting a Gradle Daemon

> Task :startQFTest
Starting QF-Test (local)

BUILD SUCCESSFUL in 7s
3 actionable tasks: 3 executed

Our plugin class is compiled, QF-Test starts up – but no output! What went wrong?

By default, the startQFTest task is used to start QF-Test interactively in a “fire-and-forget” manner – no outputs are attached and the Gradle task does not wait until QF-Test is closed. To see the debug output, we must change the fork property of the task, by adding this new definition to the build.gradle:

task startQFTestAndWait(type: StartQFTestTask) {  
    fork = false  
}

Now, we use this new task to start QF-Test, and our output becomes visible:

% ./gradlew startQFTestAndWait

> Task :startQFTestAndWait
Starting QF-Test (local)

Hello plugin world!
<=========----> 75% EXECUTING [17s]
> :startQFTestAndWait

The init() method is called very early during the startup of QF-Test or the SUT, as soon as the class has been loaded. You can distinguish different execution contexts by calling the static methods isRunningInSUT() (i.e. SUT (true) or QF-Test (false)) and isRunningInteractively() (interactive (true) or batch mode (false)) of the class de.qfs.apps.qftest.shared.Util.

If you want to delay execution until QF-Test has loaded or the SUT has been connected, you can listen for the "qftest-loaded" or "sut-loaded" notifications respectively:

import de.qfs.lib.notifications.DefaultNotificationCenter;  
import de.qfs.lib.notifications.Notification;  

[...]

@Override  
public void init() {  
    System.out.println("Plugin init");  
    DefaultNotificationCenter.instance().addObserver(this::qftestLoaded,"qftest-loaded");  
    DefaultNotificationCenter.instance().addObserver(this::sutLoaded,"sut-loaded");  
}  

private void qftestLoaded(Notification n) {  
    System.out.println("QF-Test loaded");  
}  

private void sutLoaded(Notification n) {  
    System.out.println("SUT loaded");  
}

Notifications are a powerful mechanism in QF-Test to send synchronous messages (= well defined Strings with optional additional data) in a decoupled way. The concept is well known from the Apple Foundation framework.

You can also use notifications in your QF-Test scripts – just type “notifications.” in a script and press Ctrl+Space to get a documentation about the available UserNotifications and simplified sender and observer methods. We can also use such a UserNotifications with the notification observer technique – e.g. to monitor test execution state in a basic fashion (If compilation fails due to a class file version issue, make sure you’re using at least JDK 17 for your project):

import de.qfs.apps.qftest.extensions.qftest.TestRunEvent;  
import de.qfs.apps.qftest.extensions.qftest.TestSuiteNode;
import de.qfs.apps.qftest.shared.script.modules.UserNotifications;

[...]

public class WebStatusPlugin implements QFTestPlugin {  

    public final Queue<TestSuiteNode> nodeStack = new LinkedList<>();  
    public boolean running = false;  

    @Override  
    public void init() {  
        DefaultNotificationCenter.instance().addObserver(this::runStarted,
            UserNotifications.RUN_STARTED);  
        DefaultNotificationCenter.instance().addObserver(this::runStopped, 
            UserNotifications.RUN_STOPPED);  

        DefaultNotificationCenter.instance().addObserver(this::nodeEntered, 
            UserNotifications.NODE_ENTERED);  
        DefaultNotificationCenter.instance().addObserver(this::nodeExited, 
            UserNotifications.NODE_EXITED);  
    }  

    private void runStarted(Notification notification) {  
        nodeStack.clear();  
        running = true;  
    }  

    private void runStopped(Notification notification) {  
        running = false;  
    }  

    private void nodeEntered(Notification notification) {  
        TestRunEvent event = 
            (TestRunEvent) notification.getUserInfoValue("event");  
        nodeStack.add(event.getNode());  
    }  

    private void nodeExited(Notification notification) {  
        nodeStack.poll();  
    }  

}

In order to present the current test execution state in the browser, we need an embedded web server delivering this information as a web page. Unfortunately, Java 17 (which is used to execute QF-Test) does not include a simple HTTP server module yet (this has only been introduced with Java 18). But a look in the lib library of QF-Test reveals that the undertow library is bundled, which includes a simple HTTP server class. When we add 'undertow' to the devScopes property, the corresponding library bundled with QF-Test is automatically added to our implementation dependencies:

qftest {  
    version = 'local'  
    pluginClass = 'de.qfs.apps.qftest.plugins.WebStatusPlugin'
    devScopes = ['qftest', 'undertow']
}

With this library, we sketch out a simple WebStatusServer class which returns the current execution state upon request:

package de.qfs.apps.qftest.plugins;  

import io.undertow.Undertow;  
import io.undertow.server.HttpServerExchange;    
import io.undertow.util.Headers;

public class WebStatusServer {  
    public WebStatusServer(WebStatusPlugin status) {  
        Undertow server = Undertow.builder()  
                .addHttpListener(9000,"localhost")  
                .setHandler(e -> {  
                    if (status.running) {  
                        var node = status.nodeStack.peek();  
                        if (node != null) {  
                            output(e, node.getType() + ": " + node.getName());  
                        } else {  
                            output(e,"Test execution running");  
                        }  
                    } else {  
                        output(e, "Test execution stopped");  
                    }}).build();  
        server.start();

        Runtime.getRuntime().addShutdownHook(new Thread(server::stop));

        final Undertow.ListenerInfo listenerInfo = server.getListenerInfo().iterator().next();
        System.out.println("QF-Test status available at " +
                listenerInfo.getProtcol() + ":/" + listenerInfo.getAddress());
    }  

    protected void output(HttpServerExchange exchange,  
                          String response) {    
        exchange.getResponseHeaders().add(Headers.REFRESH,"1");
        exchange.getResponseSender().send(response);  
        exchange.endExchange();  
    }  
}

We load this web server in the WebStatusPlugin class as soon as QF-Test has loaded:

private void qftestLoaded(Notification notification) {  
    new WebStatusServer(this);  
}

But unfortunately, the start of our plugin now fails:

% ./gradlew startQFTestAndWait

> Task :startQFTestAndWait
Starting QF-Test (local)
1 (...) main de.qfs.lib.notifications.DefaultNotification.getDefaultExceptionHandler().ExceptionHandler.handleException(Throwable,Notification,Observer): (#147) exception: java.lang.NoClassDefFoundError: io/undertow/Undertow (...)

The undertow library appears to be bundled by QF-Test, but is not normally available in the default classpath, so we have to do some reflection calls to add the library to the classpath and instantiate it – luckily the QF-Test de.qfs.lib package has helper methods for these tasks:

import de.qfs.apps.qftest.shared.system.Native;
import de.qfs.lib.util.DynamicClassLoader;  
import de.qfs.lib.util.Reflector;

[...]

private void qftestLoaded(Notification notification) {  
    ClassLoader cl = this.getClass().getClassLoader();  
    try {  
        DynamicClassLoader.loadJarIntoClassLoader(cl, 
                Native.getVersionDir() + "/lib/undertow.jar");
        Class<?> serverClass =  
                cl.loadClass("de.qfs.apps.qftest.plugins.WebStatusServer");  
        Reflector.createInstance(serverClass, WebStatusPlugin.class, this);  
    } catch (Exception ex) {  
        System.err.println("Could not start WebStatus server: ");  
        ex.printStackTrace();  
    }  
}

Now start QF-Test, head over to [http://localhost:9000] and watch our test progress on every automatic reload!

Finally, to ship this great new QF-Test plugin, we build an all-containing .jar file using ./gradlew jar and copy the resulting file from the build/libs folder to the plugin/qftest folder of QF-Test, so it is available in all our test runs.

In an upcoming blog post, we’ll see how easy it is to use the QF-Test plugin mechanism to extend the new QF-Test 8 Assertion API. Until then, let this post inspire your creativity!

How can I extend my QF-Test maintenance contract?

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

Just get in touch with us

Is QF-Test a low-code/no-code tool?

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

Yes! QF-Test is designed as low-code software so that you can develop, run and maintain your tests without programming knowledge using “capture and replay”.

How much does QF-Test cost?

2025-01-08T00:00:00+01:00

You can choose between purchasing a persistent license or a subscription license. All QF-Test licenses are “floating” within a network.

Prices

When can I use the latest QF-Test version?

2025-01-08T00:00:00+01:00

Your QF-Test license knows your maintenance period and you can always download and use the latest version from our homepage…

What do the version numbers mean e.g. QF-Test Version 7.1.2?

2025-01-07T00:00:00+01:00

QF-Test licenses are generally valid for all minor versions within the same major.medium version, plus all older QF-Test versions.

Minor upgrades are free of charge
Major and Medium upgrades are liable to costs or included in the maintenance contract.

If you have an old QF-Test version and want to upgrade it, please contact us directly.

Major upgrade

A major upgrade refers to the “first” version number, e.g. from 6.4.3 to 7.0.0.

Medium upgrade

Amediumupgrade refers to the version number in the “middle” , e.g. from 7.0.0 to 7.1.0.

Minor upgrade

Minor upgrades (=Updates) e.g. from 7.0.1 to 7.0.2 are in general free of charge as they mainly contain bug fixes and are part of the product warranty.

Who is using QF-Test?

2025-01-07T00:00:00+01:00

More than 1,400 companies in over 60 countries rely on QF-Test. More than 8,500 licenses are in use from small companies up to the largest IT service providers

QF-Test

Using GitHub Copilot CLI via Remote SSH from QF-Test

Prerequisites

Step-by-Step Guide

Preparation on the Client VM

Preparation on the Target VM

Functional Test (Client VM → Target VM, headless)

Troubleshooting

Connect Copilot CLI to QF-Test via SSH

QF-Test 10.0.3 available

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

Step 1: Set up Ollama

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

Step 3: Use AI in your tests

The advantages of running locally

What’s next

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

Materials

Contents

Artificial Intelligence

Our Mission

„Bring Your Own Model“

AI Configuration

Check text with AI

ai.ask and the AI Scripting Module

Test generation with QF-Test – Sneak Preview

QF-Test MCP Server

AI and Test Result Evaluation

What‘s the Price?

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

Next QF-Test special webinar

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

Download QF-Test

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

Events in 2026

QF-Test Basics: training courses via webinar

➡️February 23–26, 2026 in German

📆March 23–26, 2026 in English

Individual QF-Test company trainings

News

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

Testing ZK Applications with QF-Test

BITMARCK case study: best practice for mobile app testing

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

Master complex systems with QF-Test

Partying in cozy alpine cabin vibes

From our YouTube Channel

New video about QF-Test

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

What you’ll need

Step 1: Install and configure the GitHub Copilot CLI

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

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

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

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

Testing ZK Applications with QF-Test in 2026

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

About ABS

Automated End-to-End Testing without programming skills

Expanding test coverage

Automated nightly testing saves time and effort

Outstanding support

Conclusion

Mobile Regression Testing for iOS and Android

Expanding the GKV Software Standard BITMARCK_21c|ng

About BITMARCK

The Challenge: Seamless Quality Assurance for Mobile Channels

The Solution: Leveraging the QF-Test Platform for Mobile

Mobile Regression Testing Strategy in Detail

The Benefits

Conclusion

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

A particularly interesting aspect

Why QF-Test matters for quality engineering

Conclusion

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

QF-Test 10.0.2 available

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

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

Download QF-Test

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