QF-Test - videos

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.

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 – 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.

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!

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.

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

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!

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.

iOS included – Testing mobile apps with QF-Test

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

In this special webinar, we show you how to conveniently record and efficiently automate tests for iOS apps. Our experts also reveal tricks and tips from the field.

Automatically test iOS apps with QF-Test 8

2024-08-22T00:00:00+02:00

In this video I will show you how you can test iOS applications with QF-Test 8. Also, I will demonstrate what else QF-Test 8 has in store.

Transcript

Introduction

Hi! In this video I will show you how you can test iOS applications with QF-Test 8. Also, I will demonstrate what else QF-Test 8 has in store. QF-Test 8 is the most recent version of QF-Test, the tool for professional UI test automation.

Testing iOS applications

First, let’s get the system requirements out of the way: Testing iOS applications is only possible on macOS. Also, you need to have Xcode an a couple of other helper tools installed. To prepare your system, we have developed a useful little assistant that will lead you through the necessary steps. It will also set up your test environment for you automatically as much as possible.

As always in QF-Test, a new test project starts with the quick-start wizard, via the magic wand icon. Here I can now select an iOS device or Simulator from the list … and here I’ll select the iOS app bundle I want to test … and QF-Test takes care of all the rest for me.

With my newly created setup sequence, I can start testing. With just one click, QF-Test launches my test application and connects to the device or Simulator I just selected. Now, I can start a new recording using the QF-Test recording button. This opens the Recording Window. This Recording Window mirrors the screen contents of the connected iOS device in real-time.

When I now interact with my test application through the Recording Window, QF-Test will automatically record all of my interactions. The Simulator window was hidden to avoid confusion, but everything that happens in the recording window is transmitted live to the Simulator. Swipe gestures are also no problem for the QF-Test Recording Window.

Interactions can only be recorded through the QF-Test recording window, not directly on the device or Simulator. Instead, the recording window offers a bunch of other functionality, for example the recording of checks. Checks are used to ensure the correct state of my application. To use them, I activate the check recording mode from the recording window and then click on a UI element whose properties I want to check.

After finishing my recording, I get a test sequence made of individual steps which I can now tweak and modify however I like. But most importantly, I can replay the steps reproducibly and with great speed.

And that’s it! The first step on the road to complete end-to-end tests for my application.

Updates to the foundations

But of course that is not everything that is new in QF-Test 8. Even if you don’t plan to test iOS applications, there is a lot here to make an upgrade worth it.

For example, we have modernized the foundations and are now running on Java 17 and 64 bit, which should make QF-Test quicker, more stable and better integrated into your operating system.

Of course you can still test applications built on Java 8 as well. Also, QF-Test is still able to test 32-bit Windows applications. And on the Mac, QF-Test now runs natively on Apple Silicon. Naturally, QF-Test still works with Intel-based applications as well.

Json and Chai

As the developers behind QF-Test, we know that many of our users also work with code-based tools for testing software. One of them is the well-known JavaScript library “chai.js”.

QF-Test has also been offering code based testing since the beginning. With QF-Test 8, we let ourselves be inspired by Chai and now offer the QF-Test Assertions API.

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)

With it, you can use QF-Test to write assertions in a fluid, language-like syntax, like the one Chai made popular. And the whole thing not only works in JavaScript, but in all three supported script languages: Groovy, Jython and JavaScript.

It gets even better when you combine the Assertions API with our new JSON module and directly access individual properties in a JSON object in your assertions.

rc.setLocal("jsonData", """
{
    "Actors": [
        {
            "name": "Robert Downey Jr.",
            "age": 53,
            "Born At": "New York City, NY",
            "Birthdate": "April 4, 1965",
            "wife": "Susan Downey",
            "weight": 77.1,
            "hasChildren": true,
            "hasGreyHair": false,
            "children": [
                "Indio Falconer",
                "Avri Roel",
                "Exton Elias"
            ]
        }
    ]
}""")
def data = rc.getJson("jsonData")
data.Actors.should.be.a("ArrayList")
expect(data.Actors[0]).to.be.a("LinkedHashMap")
Assert.instanceOf(data.Actors[0], "LinkedHashMap", "Bla")
data.Actors[0].name.should.be.a("String")
data.Actors[0].age.should.be.a("Long")
data.Actors[0].weight.should.be.a("Double")
data.Actors[0].hasChildren.should.be.a("Boolean")
rc.setGlobalJson("gData",data)

New Theme: Solarized

Even if you are only in the mood for some visual variety, QF-Test 8 is for you. We have turned the popular Solarized color scheme into a UI theme. It joins our existing default theme and the high contrast mode. With it’s deliberately tuned colors, Solarized brings even more choice to the visual presentation of QF-Test. And of course, this theme, too, is available in a light variant.

Conclusion

And there are even more things that are new in QF-Test 8. There are a ton of smaller improvements and fixes. Visit our website and take a look at the full release notes to learn about all the details.

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

The Quickstart Wizard for PDF

2024-05-16T00:00:00+02:00

When testing PDF documents all this is possible: Checking of content, texts, images/geometry and comparisons.

Further information in the manual

The QF-Test UI Inspector in use

2024-04-29T00:00:00+02:00

The UI inspector of QF-Test is a valuable tool to better understand the structure of the UI to be tested.

In this video, we will show you how you can use the UI inspector to quickly configure your CustomWebResolver, for example, and what tricks the tool also offers for Windows and Java applications.

The Quickstart Wizard for Web

2024-04-04T00:00:00+02:00

In this video we’ll show how to define a web application as test object in QF-Test in just a view steps in order to be able to start directly with test development.

Further information

QF-Test Version 7.1 Highlights

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

With new display options, resolvers and more.

Revised tree view
Better display options
Script languages in step conditions
High-contrast theme
UI Inspector for Windows and Swing Apps
CustomWebResolver improvements
News resolvers for Flutter, Vaadin 14+ and ARIA
Easy drawing on images and screenshots

Further information

Testing Android applications with QF-Test I UI test automation

2022-10-24T00:00:00+02:00

QF-Test supports testing Android applications both in emulators and on real devices.

Testing Web applications with QF-Test I UI test automation

2022-08-16T00:00:00+02:00

For classic static HTML websites and dynamic Frameworks (Angular, React, Vue.js, Vaadin etc.)
Cross-browser testing: Google Chrome, Mozilla Firefox, Microsoft Edge (headless, too), as well as Opera and Safari
Testing Electron applications, Webswing and JPro

Sweet like Nougat, Oreo, and Pie – Testing Android with QF-Test

2022-07-11T00:00:00+02:00

Testing Android with QF-Test on real devices e.g. from Samsung, LG and Google as well as with the emulator from Android Studio.

Further information

Spring-clean in May – Optimizing the test structure and documentation in QF-Test

2022-06-15T00:00:00+02:00

Optimize your test structure and documentation for all stakeholders: colleagues, bosses and clients.

Testsuite

Testing Java Swing with QF-Test

2022-05-30T00:00:00+02:00

QF-Test supports Java Swing specifically WebView, JxBrowser, Webswing and JPro cross-platform on Windows, Linux and macOS.
QF-Test itself is based on Java and therefore offers the best possible support for your Java Swing applications.

Highlights of QF-Test Version 6.0 with Android, SmartIDs and much more

2022-05-17T00:00:00+02:00

New features and improvements.

Testing Android applications
SmartIDs for component recognition
Java17, Groovy 4, more modern HTML reports
Run-log with relative execution time and optimized screenshots
Connection to the Robot-Framework

Testing JavaFX with QF-Test I UI test automation

2022-05-03T00:00:00+02:00

QF-Test supports JavaFX specifically WebView, JxBrowser, Webswing and JPro cross-platform on Windows, Linux and macOS.
QF-Test itself is based on Java and therefore offers the best possible support for your JavaFX applications.

Using the Debugger

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

Tutorial chapter

Dos and Don’ts when Working with QF-Test as a Team

2022-01-26T00:00:00+01:00

Webswing brings Java into the browser
QF-Test ensures the quality by interacting with both simultaneously

QF-Test and Webswing

Find the keys – UI test automation needs robust component recognition

2020-10-06T00:00:00+02:00

Component recognition in QF-Test is quite flexible. In addition to standard controls like buttons or checkboxes it also supports complex components (dynamic trees, tables etc.). This webinar shows the basics of this algorithm and configuration options for Java, Web and Windows applications. We will explain how to achieve robust component recognition.

Further information

QF-Test and 3rd-party tools

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

This video is about the integration of QF‑Test in 3rd-party tools (Continuous integration, Test management, developer tools etc.) as well as triggering test execution and controlling reports.

Further information

QF-Test Version 5.1 – Embedded browsers

2020-07-08T00:00:00+02:00

The medium upgrade QF-Test 5.1 focuses on bringing support for embedded browsers – JxBrowser (including version 7), SWT Browser and JavaFX WebView, up to par with that for “normal” browsers. It also comes with support for Java 15, native Electron dialogs and customizable HTML reports. The internal JRE provided with QF-Test has been updated to Zulu OpenJDK 8_252.

QF-Test for UI-based Load Tests

2020-06-29T00:00:00+02:00

This video shows you how you can create system load via the UI with the QF-Test Demo test suite for monitoring and measuring real end-to-end times as well as user acceptance times and ressources needed.

Further information

Testing native Windows applications with QF-Test

2020-05-04T00:00:00+02:00

There are no changes to the familiar QF-Test workflow and you can connect to your application using window titles.

Classic Win32 applications
.NET applications (often developed in C#) based on Windows Presentation Foundation (WPF) or Windows Forms
Windows Apps / Universal Windows Platform (UWP) applications using XAML controls
Modern C++ applications (for example Qt applications)

Further information

QF-Test Version 5.0 – Testing Windows applications

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

There are no changes to the familiar QF-Test workflow in testing Windows desktop applications and you can connect to your application using window titles.

Highlights QF-Test Version 5.0

New Engine for Windows applications
Modernized User Interface of QF‑Test
Tests with Java 14
Test-suites with comments Comment node

Variables in QF-Test

2019-04-08T00:00:00+02:00

What are variables in QF-Test for? Reading of test data, retreating test data during the test-run, reusing of a check for a better test flow for more flexible and maintainable tests.

Further information

QF-Test Jenkins Plugin

2015-10-05T00:00:00+02:00

Jenkins is a continuous integration build tool. Therefore it is meant to control and monitor the build process within a software project. One important step in this build process is automated testing for example UI tests with QF-Test.

Further information

QF-Test - videos

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?

Welcome to QF-Test

QF-Test 10 – WebAPI, AI and more

Transcript

WebAPI

AI Integration and the AI Text Check

Updated Accessibility (A11y) Checks for Websites

New Nodes for Image Handling

Product Editions

Modeless Editing

New Debugger Dialog on Errors

Improved Manual

Scripting in QF-Test (basics)

Transcript

Script Types

SUT script example

Pseudo DOM API and accessing native Java component methods

The QF-Test run context

An example server script

Outlook

Dependencies in QF-Test (basics)

Materials for this video

Abridged Transcript

Opening the Test Suite

Running Test Cases

Introducing Dependencies

Creating a Simple Dependency

Testing the Dependency

Full Test Set Execution with Dependency

How Dependencies Work

Advanced Behavior

Reusing Dependencies

Conclusion

Going POSTal! Discover WebAPI Testing in QF-Test

Summary

Introduction to Web API Testing

Demo: Using the New Web Request Node

Pre- and Post-Request Handlers

Test Cases, Variables, and Assertions

Scripting and Technical Background

Authentication

SOAP Example

Proxy and Certificate Management

Future Outlook

Conclusion

Beyond Strings – How To Effectively Use Object Variables In QF-Test 9

Contents

Code examples and summaries

Until QF-Test 8: All variables are Strings

Automatic Conversion

Since QF-Test 9: Variables store original object

Representation in run log and protocol

Simplified access in scripts

Default values

Return value in procedures

Conversion if required

Variable exchange QF-Test <-> SUT

Additional information

Web Accessibility Testing with QF-Test

Abridged Transcript

Agenda

What Is Accessibility?

Web Accessibility

Why Make Websites Accessible?

Accessibility Laws and Regulations

European Accessibility Act (EAA)

Web Content Accessibility Guidelines (WCAG)