Add files using upload-large-folder tool

qt/6.8.1/msvc2022_64/bin/ensure_pro_file.cmake

@@ -0,0 +1,19 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+# CMake script to ensure that a qmake project file exists.
+#
+# Usage: cmake -DPRO_FILE=.../project.pro -P .../ensure_pro_file.cmake
+#
+# This script checks for existence of ${PRO_FILE} and creates a fake one, if needed.
+#
+
+if(NOT EXISTS "${PRO_FILE}")
+    get_filename_component(dir "${PRO_FILE}" DIRECTORY)
+    if(NOT IS_DIRECTORY "${dir}")
+        file(MAKE_DIRECTORY "${dir}")
+    endif()
+
+    file(WRITE "${PRO_FILE}" "TEMPLATE = aux
+")
+endif()

qt/6.8.1/msvc2022_64/bin/qt-android-runner.py

@@ -0,0 +1,205 @@
+#!/usr/bin/env python3
+# Copyright (C) 2024 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+import os
+import subprocess
+import sys
+import base64
+import time
+import signal
+import argparse
+
+from datetime import datetime
+
+def status(msg):
+    print(f"\n-- {msg}")
+
+def error(msg):
+    print(f"Error: {msg}", file=sys.stderr)
+
+def die(msg):
+    error(msg)
+    sys.exit(1)
+
+# Define and parse arguments
+parser = argparse.ArgumentParser(description="Qt for Android app runner.",
+                                 epilog=f'''
+This is a helper script to run Qt for Android apps directly from the terminal.
+It supports starting apps with parameters and forwards environment variables to
+the device. It prints live logcat messages as the app is running. The script exits
+once the app has exited on the device and terminates the app on the device if the
+script is terminated.
+
+If an APK path is provided, it will first be installed to the device only if the
+--install parameter is passed.
+
+Use --serial parameter or adb's ANDROID_SERIAL environment variable to specify an
+Android target serial number (obtained from "adb devices" command) on which to run
+the app or test.
+''', formatter_class=argparse.RawTextHelpFormatter)
+
+parser.add_argument('-a', '--adb', metavar='path', type=str, help='Path to adb executable.')
+parser.add_argument('-b', '--build-path', metavar='path', type=str,
+                    help='Path to the Android build directory.')
+parser.add_argument('-i', '--install', action='store_true', help='Install the APK.')
+parser.add_argument('-s', '--serial', type=str, metavar='serial',
+                    help='Android device serial (override $ANDROID_SERIAL).')
+parser.add_argument('-p', '--apk', type=str, metavar='path', help='Path to the APK file.')
+
+
+args, remaining_args = parser.parse_known_args()
+
+# Validate required arguments
+if not args.build_path:
+    die("App build path is not provided")
+
+adb = args.adb
+if not adb:
+    adb = 'adb'
+    null_dev = subprocess.DEVNULL
+    if subprocess.call(['command', '-v', adb], stdout=null_dev, stderr=null_dev) != 0:
+        die("adb tool path is not provided and is not found in PATH")
+
+try:
+    devices = []
+    output = subprocess.check_output(f"{adb} devices", shell=True).decode().strip()
+    for line in output.splitlines():
+        if '\tdevice' in line:
+            serial = line.split('\t')[0]
+            devices.append(serial)
+    if not devices:
+        die(f"No devices are connected.")
+
+    if args.serial and not args.serial in devices:
+        die(f"No connected devices with the specified serial number.")
+except Exception as e:
+    die(f"Failed to check for running devices, received error: {e}")
+
+if args.serial:
+    adb = f"{adb} -s {args.serial}"
+
+if args.build_path is None:
+    die("App build path is not provided")
+
+if args.apk and args.install:
+    status(f"Installing the app APK {args.apk}")
+    try:
+        subprocess.run(f"{adb} install \"{args.apk}\"", check=True, shell=True)
+    except Exception as e:
+        error(f"Failed to install the APK, received error: {e}")
+
+
+def get_package_name(build_path):
+    try:
+        manifest_file = os.path.join(args.build_path, "AndroidManifest.xml")
+        if os.path.isfile(manifest_file):
+            with open(manifest_file) as f:
+                for line in f:
+                    if 'package="' in line:
+                        return line.split('package="')[1].split('"')[0]
+
+        gradle_file = os.path.join(args.build_path, "build.gradle")
+        if os.path.isfile(gradle_file):
+            with open(gradle_file) as f:
+                for line in f:
+                    if line.strip().startswith("namespace"):
+                        return line.split('=')[1].strip().strip('"')
+
+        properties_file = os.path.join(args.build_path, "gradle.properties")
+        if os.path.isfile(properties_file):
+            with open(properties_file) as f:
+                for line in f:
+                    if line.startswith("androidPackageName="):
+                        return line.split('=')[1].strip()
+    except Exception as e:
+        error(f"Failed to retrieve the app's package name, received error: {e}")
+
+    return None
+
+# Get app details
+package_name = get_package_name(args.build_path)
+if not package_name:
+    die("Failed to retrieve the package name of the app")
+
+activity_name = "org.qtproject.qt.android.bindings.QtActivity"
+start_cmd = f"{adb} shell am start -n {package_name}/{activity_name}"
+
+# Get environment variables
+env_vars = " ".join(f"{key}={value}" for key, value in os.environ.items())
+encoded_env_vars = base64.b64encode(env_vars.encode()).decode()
+start_cmd += f" -e extraenvvars \"{encoded_env_vars}\""
+
+# Get app arguments
+if remaining_args:
+    start_cmd += f" -e applicationArguments \"{' '.join(remaining_args)}\""
+
+# Get formatted time from device
+start_timestamp = ""
+try:
+    start_timestamp = subprocess.check_output(f"{adb} shell \"date +'%Y-%m-%d %H:%M:%S.%3N'\"",
+                                              shell=True).decode().strip()
+except Exception as e:
+    die(f"Failed to get formatted time from the device, received error: {e}")
+
+try:
+    subprocess.run(start_cmd, check=True, shell=True)
+except Exception as e:
+    die(f"Failed to start the app {package_name}, received error: {e}")
+
+# Wait for the app to start and retrieve its pid
+start_timeout = 5
+time_limit = time.time() + start_timeout
+pid = None
+while pid is None:
+    if time.time() > time_limit:
+        die(f"Couldn't retrieve the app's PID within {start_timeout} seconds")
+    time.sleep(0.5)
+    try:
+        pidof_output = subprocess.check_output(f"{adb} shell pidof {package_name}", shell=True)
+        pid = pidof_output.decode().strip().split()[0]
+    except subprocess.CalledProcessError:
+        continue
+
+# Add a signal handler to stop the app if the script is terminated
+interrupted = False
+def terminate_app(signum, frame):
+    global interrupted
+    interrupted = True
+
+signal.signal(signal.SIGINT, terminate_app)
+
+# Show app's logs
+try:
+    format_arg = "-v brief -v color"
+    time_arg = f"-T '{start_timestamp}'"
+    # escape char and color followed with fatal tag
+    fatal_regex = f"-e $'^\x1b\\[[0-9]*mF/'"
+    pid_regex = f"-e '([ ]*{pid}):'"
+    logcat_cmd = f"{adb} shell \"logcat {time_arg} {format_arg} | grep {pid_regex} {fatal_regex}\""
+    logcat_process = subprocess.Popen(logcat_cmd, shell=True)
+except Exception as e:
+    die(f"Failed to get logcat for the app {package_name}, received error: {e}")
+
+# Monitor the app's pid
+try:
+    while not interrupted:
+        time.sleep(1)
+        try:
+            pidof_output = subprocess.check_output(f"{adb} shell pidof {package_name}", shell=True)
+            pid = pidof_output.decode().strip()
+            if not pid:
+                status(f"The app \"{package_name}\" has exited")
+                break
+        except subprocess.CalledProcessError:
+            status(f"The app \"{package_name}\" has exited")
+            break
+finally:
+    logcat_process.terminate()
+
+if interrupted:
+    try:
+        subprocess.Popen(f"{adb} shell am force-stop {package_name}", shell=True)
+        status(f"The app \"{package_name}\" with {pid} has been terminated")
+    except Exception as e:
+        error(f"Failed to terminate the app {package_name}, received error: {e}")

qt/6.8.1/msvc2022_64/bin/qt-cmake-create.bat

@@ -0,0 +1,19 @@
+@echo off
+setlocal
+:: The directory of this script is the expanded absolute path of the "$qt_prefix/bin" directory.
+set script_dir_path=%~dp0
+
+:: Try to use original cmake, otherwise to make it relocatable, use any cmake found in PATH.
+set cmake_path=C:/CMake/bin/cmake.exe
+if not exist "%cmake_path%" set cmake_path=cmake
+
+if NOT "%~2" == "" goto :showhelp
+if NOT "%~1" == "" (set PROJECT_DIR=%~1) else (set PROJECT_DIR=%cd%)
+
+"%cmake_path%" -DPROJECT_DIR="%PROJECT_DIR%" -P "%script_dir_path%\../lib/cmake/Qt6\QtInitProject.cmake"
+exit /b %errorlevel%
+
+:showhelp
+echo Usage
+echo.    qt-cmake-create <path/to/project>
+exit /b 1

qt/6.8.1/msvc2022_64/bin/qt-cmake-private-install.cmake

@@ -0,0 +1,29 @@
+# Calls cmake --install ${QT_BUILD_DIR} --config <config> for each config
+# with which Qt was built with.
+# This is required to enable installation of all configurations of
+# a Qt built with Ninja Multi-Config until the following issues are fixed:
+# https://gitlab.kitware.com/cmake/cmake/-/issues/20713
+# https://gitlab.kitware.com/cmake/cmake/-/issues/21475
+set(configs "RelWithDebInfo;Debug")
+set(should_skip_strip "TRUE")
+
+if(NOT QT_BUILD_DIR)
+    message(FATAL_ERROR "No QT_BUILD_DIR value provided to qt-cmake-private-install.")
+endif()
+
+if(should_skip_strip)
+    unset(strip_arg)
+else()
+    set(strip_arg --strip)
+endif()
+
+foreach(config ${configs})
+    message(STATUS "Installing configuration: '${config}'")
+    set(args "${CMAKE_COMMAND}" --install ${QT_BUILD_DIR} --config "${config}" ${strip_arg})
+    execute_process(COMMAND ${args}
+                    COMMAND_ECHO STDOUT
+                    RESULT_VARIABLE result)
+    if(NOT "${result}" STREQUAL "0")
+        message(FATAL_ERROR "Installing configuration '${config}' failed with exit code: ${result}.")
+    endif()
+endforeach()

qt/6.8.1/msvc2022_64/bin/qt-cmake-private.bat

@@ -0,0 +1,11 @@
+@echo off
+setlocal
+:: The directory of this script is the expanded absolute path of the "$qt_prefix/bin" directory.
+set script_dir_path=%~dp0
+
+:: Try to use original cmake, otherwise to make it relocatable, use any cmake found in PATH.
+set cmake_path=C:/CMake/bin/cmake.exe
+if not exist "%cmake_path%" set cmake_path=cmake
+
+set toolchain_path=%script_dir_path%\../lib/cmake/Qt6\qt.toolchain.cmake
+"%cmake_path%" -DCMAKE_TOOLCHAIN_FILE="%toolchain_path%" -G"Ninja Multi-Config" -DQT_USE_ORIGINAL_COMPILER=ON %*

qt/6.8.1/msvc2022_64/bin/qt-cmake-standalone-test.bat

@@ -0,0 +1,4 @@
+@echo off
+
+set SCRIPT_DIR=%~dp0
+%SCRIPT_DIR%qt-cmake-private.bat %SCRIPT_DIR%../lib/cmake/Qt6BuildInternals/QtStandaloneTestTemplateProject -DQT_BUILD_STANDALONE_TESTS=ON -DQT_STANDALONE_TEST_PATH=%* -DPWD="%CD%"

qt/6.8.1/msvc2022_64/bin/qt-cmake.bat

@@ -0,0 +1,11 @@
+@echo off
+setlocal
+:: The directory of this script is the expanded absolute path of the "$qt_prefix/bin" directory.
+set script_dir_path=%~dp0
+
+:: Try to use original cmake, otherwise to make it relocatable, use any cmake found in PATH.
+set cmake_path=C:/CMake/bin/cmake.exe
+if not exist "%cmake_path%" set cmake_path=cmake
+
+set toolchain_path=%script_dir_path%\../lib/cmake/Qt6\qt.toolchain.cmake
+"%cmake_path%" -DCMAKE_TOOLCHAIN_FILE="%toolchain_path%"  %*

qt/6.8.1/msvc2022_64/bin/qt-configure-module.bat

@@ -0,0 +1,34 @@
+@echo off
+setlocal ENABLEDELAYEDEXPANSION ENABLEEXTENSIONS
+set script_dir_path=%~dp0
+set script_dir_path=%script_dir_path:~0,-1%
+
+if "%1" == "" (
+    call :print_usage
+    exit /b 1
+)
+
+set module_root=%1
+set module_root=%module_root:\=/%
+shift
+if not exist "%module_root%\CMakeLists.txt" (
+    echo Error: %module_root% is not a valid Qt module source directory. >&2
+    call :print_usage
+    exit /b 1
+)
+
+set cmake_scripts_dir=%script_dir_path%\..\lib\cmake\Qt6
+echo %*>config.opt.in
+call "%script_dir_path%\qt-cmake.bat" -DSKIP_ARGS=1 -DIN_FILE=config.opt.in -DOUT_FILE=config.opt ^
+    -P "%cmake_scripts_dir%\QtWriteArgsFile.cmake"
+call "%script_dir_path%\qt-cmake-private.bat" -DOPTFILE=config.opt -DMODULE_ROOT="%module_root%" ^
+    -DCMAKE_COMMAND="%script_dir_path%\qt-cmake-private.bat" ^
+    -P "%cmake_scripts_dir%\QtProcessConfigureArgs.cmake"
+goto :eof
+
+:print_usage
+echo Usage: qt-configure-module ^<module-source-dir^> [options]
+echo.
+echo To display the available options for a Qt module, run
+echo qt-configure-module ^<module-source-dir^> -help
+goto :eof

qt/6.8.1/msvc2022_64/bin/qt-internal-configure-examples.bat

@@ -0,0 +1,34 @@
+@echo off
+setlocal ENABLEDELAYEDEXPANSION ENABLEEXTENSIONS
+set script_dir_path=%~dp0
+set script_dir_path=%script_dir_path:~0,-1%
+
+rem Extracts the source path, make it native, and put it
+rem back again. This is a workaround on Windows LLVM/MINGW
+rem to help CMake find source files when doing Unity Build.
+set args=%*
+set source_dir_path=
+set native_source_dir_path=
+for %%i in (%args%) do (
+    if "%%i"=="-S" (
+        set found=true
+    ) else if defined found (
+        set source_dir_path=%%i
+        set native_source_dir_path=%%~dpnxi
+        set found=
+    )
+)
+
+if NOT "%native_source_dir_path%" == "" (
+    set args=!args:%source_dir_path%=%native_source_dir_path%!
+)
+
+set cmake_scripts_dir=%script_dir_path%
+
+set relative_bin_dir=
+if NOT "%relative_bin_dir%" == "" (
+set relative_bin_dir="%relative_bin_dir%"\
+)
+
+call "%script_dir_path%"\%relative_bin_dir%"qt-cmake.bat" ^
+     -DQT_BUILD_STANDALONE_EXAMPLES=ON -DQT_BUILD_TESTS=OFF -DQT_USE_ORIGINAL_COMPILER=ON %args%

qt/6.8.1/msvc2022_64/bin/qt-internal-configure-tests.bat

@@ -0,0 +1,34 @@
+@echo off
+setlocal ENABLEDELAYEDEXPANSION ENABLEEXTENSIONS
+set script_dir_path=%~dp0
+set script_dir_path=%script_dir_path:~0,-1%
+
+rem Extracts the source path, make it native, and put it
+rem back again. This is a workaround on Windows LLVM/MINGW
+rem to help CMake find source files when doing Unity Build.
+set args=%*
+set source_dir_path=
+set native_source_dir_path=
+for %%i in (%args%) do (
+    if "%%i"=="-S" (
+        set found=true
+    ) else if defined found (
+        set source_dir_path=%%i
+        set native_source_dir_path=%%~dpnxi
+        set found=
+    )
+)
+
+if NOT "%native_source_dir_path%" == "" (
+    set args=!args:%source_dir_path%=%native_source_dir_path%!
+)
+
+set cmake_scripts_dir=%script_dir_path%
+
+set relative_bin_dir=
+if NOT "%relative_bin_dir%" == "" (
+set relative_bin_dir="%relative_bin_dir%"\
+)
+
+call "%script_dir_path%"\%relative_bin_dir%"qt-cmake.bat" ^
+     -DQT_BUILD_STANDALONE_TESTS=ON -DQT_BUILD_EXAMPLES=OFF -DQT_USE_ORIGINAL_COMPILER=ON %args%

qt/6.8.1/msvc2022_64/bin/qt-testrunner.py

@@ -0,0 +1,395 @@
+#!/usr/bin/env python3
+# Copyright (C) 2021 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+
+# !!!IMPORTANT!!!  If you change anything to this script, run the testsuite
+#    manually and make sure it still passes, as it doesn't run automatically.
+#    Just execute the command line as such:
+#
+#      ./util/testrunner/tests/tst_testrunner.py -v [--debug]
+#
+# ======== qt-testrunner ========
+#
+# This script wraps the execution of a Qt test executable, for example
+# tst_whatever, and tries to iron out unpredictable test failures.
+# In particular:
+#
+# + Appends output argument to it: "-o tst_whatever.xml,xml"
+# + Checks the exit code. If it is zero, the script exits with zero,
+#   otherwise proceeds.
+# + Reads the XML test log and Understands exactly which function
+#   of the test failed.
+#   + If no XML file is found or was invalid, the test executable
+#     probably CRASHed, so we *re-run the full test once again*.
+# + If some testcases failed it executes only those individually
+#   until they pass, or until max-repeats times is reached.
+#
+# The regular way to use is to set the environment variable TESTRUNNER to
+# point to this script before invoking ctest.
+#
+# NOTE: this script is crafted specifically for use with Qt tests and for
+#       using it in Qt's CI. For example it detects and acts specially if test
+#       executable is "tst_selftests" or "androidtestrunner".  It also detects
+#       env var "COIN_CTEST_RESULTSDIR" and uses it as log-dir.
+#
+# TODO implement --dry-run.
+
+# Exit codes of this script:
+#   0: PASS. Either no test failed, or failed initially but passed
+#      in the re-runs (FLAKY PASS).
+#   1: Some unexpected error of this script.
+#   2: FAIL! for at least one test, even after the individual re-runs.
+#   3: CRASH! for the test executable even after re-running it once.
+#        Or when we can't re-run individual functions for any reason.
+
+
+import sys
+if sys.version_info < (3, 6):
+    sys.stderr.write(
+        "Error: this test wrapper script requires Python version 3.6 at least\n")
+    sys.exit(1)
+
+import argparse
+import subprocess
+import os
+import traceback
+import time
+import timeit
+import xml.etree.ElementTree as ET
+import logging as L
+
+from pprint import pprint
+from typing import NamedTuple, Tuple, List, Optional
+
+# Define a custom type for returning a fail incident
+class WhatFailed(NamedTuple):
+    func: str
+    tag: Optional[str] = None
+
+
+# In the last test re-run, we add special verbosity arguments, in an attempt
+# to log more information about the failure
+VERBOSE_ARGS = ["-v2", "-maxwarnings", "0"]
+VERBOSE_ENV = {
+    "QT_LOGGING_RULES": "*=true",
+    "QT_MESSAGE_PATTERN": "[%{time process} %{if-debug}D%{endif}%{if-warning}W%{endif}%{if-critical}C%{endif}%{if-fatal}F%{endif}] %{category} %{file}:%{line} %{function}()  -  %{message}",
+}
+# The following special function names can not re-run individually.
+NO_RERUN_FUNCTIONS = {
+    "initTestCase", "init", "cleanup", "cleanupTestCase"
+}
+# The following tests do not write XML log files properly. qt-testrunner will
+# not try to append "-o" to their command-line or re-run failed testcases.
+# Only add tests here if absolutely necessary!
+NON_XML_GENERATING_TESTS = {
+    "tst_selftests",                # qtestlib's selftests are using an external test framework (Catch) that does not support -o argument
+    "tst_QDoc",                     # Some of QDoc's tests are using an external test framework (Catch) that does not support -o argument
+    "tst_QDoc_Catch_Generators",    # Some of QDoc's tests are using an external test framework (Catch) that does not support -o argument
+}
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(formatter_class=argparse.RawDescriptionHelpFormatter,
+        description="""
+Wrap Qt test execution. This is intended to be invoked via the TESTRUNNER
+environment variable before running ctest in the CI environment. The purpose
+of the script is to repeat failed tests in order to iron out transient errors
+caused by unpredictable factors. Individual test functions that failed are
+retried up to max-repeats times until the test passes.
+        """,
+        epilog="""
+Default flags: --max-repeats 5 --passes-needed 1
+        """
+    )
+    parser.add_argument("testargs", metavar="TESTARGS", nargs="+",
+                        help="Test executable and arguments")
+    parser.add_argument("--log-dir", metavar="DIR",
+                        help="Where to write the XML log files with the test results of the primary test run;"
+                        " by default write to CWD")
+    parser.add_argument("--max-repeats", type=int, default=5, metavar='N',
+                        help="In case the test FAILs, repeat the failed cases this many times")
+    parser.add_argument("--passes-needed", type=int, default=1, metavar='M',
+                        help="Number of repeats that need to succeed in order to return an overall PASS")
+    parser.add_argument("--parse-xml-testlog", metavar="file.xml",
+                        help="Do not run the full test the first time, but parse this XML test log;"
+                        " if the test log contains failures, then re-run the failed cases normally,"
+                        " as indicated by the other flags")
+    parser.add_argument("--dry-run", action="store_true",
+                        help="(TODO - not implemented yet) Do not run anything, just describe what would happen")
+    parser.add_argument("--timeout", metavar="T",
+                        help="Timeout for each test execution in seconds")
+    parser.add_argument("--no-extra-args", action="store_true",
+                        help="Do not append any extra arguments to the test command line, like"
+                        " -o log_file.xml -v2 -vs. This will disable some functionality like the"
+                        " failed test repetition and the verbose output on failure. This is"
+                        " activated by default when TESTARGS is tst_selftests.")
+    args = parser.parse_args()
+    args.self_name = os.path.basename(sys.argv[0])
+    args.specific_extra_args = []
+
+    logging_format = args.self_name + " %(levelname)8s: %(message)s"
+    L.basicConfig(format=logging_format, level=L.DEBUG)
+
+    if args.log_dir is None:
+        if "COIN_CTEST_RESULTSDIR" in os.environ:
+            args.log_dir = os.environ["COIN_CTEST_RESULTSDIR"]
+            L.info("Will write XML test logs to directory"
+                   " COIN_CTEST_RESULTSDIR=%s", args.log_dir)
+        else:
+            args.log_dir = "."
+
+    args.test_basename = os.path.basename(args.testargs[0])
+
+    if args.test_basename.endswith(".exe"):
+        args.test_basename = args.test_basename[:-4]
+
+    # QNX test wrapper just needs to be skipped to figure out test_basename
+    if args.test_basename == "coin_qnx_qemu_runner.sh":
+        args.test_basename = os.path.basename(args.testargs[1])
+        L.info("Detected coin_qnx_qemu_runner, test will be handled specially. Detected test basename: %s",
+               args.test_basename)
+
+    # On Android emulated platforms, "androidtestrunner" is invoked by CMake
+    # to wrap the tests.  We have to append the test arguments to it after
+    # "--". Besides that we have to detect the basename to avoid saving the
+    # XML log as "androidtestrunner.xml" for all tests.
+    if args.test_basename == "androidtestrunner":
+        args.specific_extra_args = [ "--" ]
+        apk_arg = False
+        for a in args.testargs[1:]:
+            if a == "--apk":
+                apk_arg = True
+            elif apk_arg:
+                apk_arg = False
+                if a.endswith(".apk"):
+                    args.test_basename = os.path.basename(a)[:-4]
+                    break
+        L.info("Detected androidtestrunner, test will be handled specially. Detected test basename: %s",
+               args.test_basename)
+
+    if args.test_basename in NON_XML_GENERATING_TESTS:
+        L.info("Detected special test not able to generate XML log! Will not parse it and will not repeat individual testcases")
+        args.no_extra_args = True
+        args.max_repeats = 0
+
+    return args
+
+
+def parse_log(results_file) -> List[WhatFailed]:
+    """Parse the XML test log file. Return the failed testcases, if any.
+
+    Failures are considered the "fail" and "xpass" incidents.
+    A testcase is a function with an optional data tag."""
+    start_timer = timeit.default_timer()
+
+    try:
+        tree = ET.parse(results_file)
+    except FileNotFoundError:
+        L.error("XML log file not found: %s", results_file)
+        raise
+    except Exception as e:
+        L.error("Failed to parse the XML log file: %s", results_file)
+        with open(results_file, "rb") as f:
+            if os.stat(f.fileno()).st_size == 0:
+                L.error("    File is empty")
+            else:
+                L.error("    File Contents:\n%s\n\n",
+                        f.read().decode("utf-8", "ignore"))
+        raise
+
+    root = tree.getroot()
+    if root.tag != "TestCase":
+        raise AssertionError(
+            f"The XML test log must have <TestCase> as root tag, but has: <{root.tag}>")
+
+    failures = []
+    n_passes = 0
+    for e1 in root:
+        if e1.tag == "TestFunction":
+            for e2 in e1:                          # every <TestFunction> can have many <Incident>
+                if e2.tag == "Incident":
+                    if e2.attrib["type"] in ("fail", "xpass"):
+                        func = e1.attrib["name"]
+                        e3 = e2.find("DataTag")    # every <Incident> might have a <DataTag>
+                        if e3 is not None:
+                            failures.append(WhatFailed(func, tag=e3.text))
+                        else:
+                            failures.append(WhatFailed(func))
+                    else:
+                        n_passes += 1
+
+    end_timer = timeit.default_timer()
+    t = end_timer - start_timer
+    L.info(f"Parsed XML file {results_file} in {t:.3f} seconds")
+    L.info(f"Found {n_passes} passes and {len(failures)} failures")
+
+    return failures
+
+
+def run_test(arg_list: List[str], **kwargs):
+    L.debug("Running test command line: %s", arg_list)
+    proc = subprocess.run(arg_list, **kwargs)
+    L.info("Test process exited with code: %d", proc.returncode)
+
+    return proc
+
+def unique_filename(test_basename: str) -> str:
+    timestamp = round(time.time() * 1000)
+    return f"{test_basename}-{timestamp}"
+
+# Returns tuple: (exit_code, xml_logfile)
+def run_full_test(test_basename, testargs: List[str], output_dir: str,
+                  no_extra_args=False, dryrun=False,
+                  timeout=None, specific_extra_args=[])  \
+        -> Tuple[int, Optional[str]]:
+
+    results_files = []
+    output_testargs = []
+
+    # Append arguments to write log to qtestlib XML file,
+    # and text to stdout.
+    if not no_extra_args:
+        filename_base = unique_filename(test_basename)
+        pathname_stem = os.path.join(output_dir, filename_base)
+        xml_output_file = f"{pathname_stem}.xml"
+
+        results_files.append(xml_output_file)
+        output_testargs.extend([
+            "-o", f"{xml_output_file},xml",
+            "-o", f"{pathname_stem}.junit.xml,junitxml",
+            "-o", f"{pathname_stem}.txt,txt",
+            "-o", "-,txt"
+            ])
+
+    proc = run_test(testargs + specific_extra_args + output_testargs,
+                    timeout=timeout)
+
+    return (proc.returncode, results_files[0] if results_files else None)
+
+
+def rerun_failed_testcase(test_basename, testargs: List[str], output_dir: str,
+                          what_failed: WhatFailed,
+                          max_repeats, passes_needed,
+                          dryrun=False, timeout=None) -> bool:
+    """Run a specific function:tag of a test, until it passes enough times, or
+    until max_repeats is reached.
+
+    Return True if it passes eventually, False if it fails.
+    """
+    assert passes_needed <= max_repeats
+    failed_arg = what_failed.func
+    if what_failed.tag:
+        failed_arg += ":" + what_failed.tag
+
+
+    n_passes = 0
+    for i in range(max_repeats):
+        # For the individual testcase re-runs, we log to file since Coin needs
+        # to parse it. That is the reason we use unique filename every time.
+        filename_base = unique_filename(test_basename)
+        pathname_stem = os.path.join(output_dir, filename_base)
+
+        output_args = [
+            "-o", f"{pathname_stem}.xml,xml",
+            "-o", f"{pathname_stem}.junit.xml,junitxml",
+            "-o", f"{pathname_stem}.txt,txt",
+            "-o", "-,txt"]
+        L.info("Re-running testcase: %s", failed_arg)
+        if i < max_repeats - 1:
+            proc = run_test(testargs + output_args + [failed_arg],
+                            timeout=timeout)
+        else:                                                   # last re-run
+            proc = run_test(testargs + output_args + VERBOSE_ARGS + [failed_arg],
+                            timeout=timeout,
+                            env={**os.environ, **VERBOSE_ENV})
+        if proc.returncode == 0:
+            n_passes += 1
+        if n_passes == passes_needed:
+            L.info("Test has PASSed as FLAKY after re-runs:%d, passes:%d, failures:%d",
+                   i+1, n_passes, i+1-n_passes)
+            return True
+
+    assert n_passes <  passes_needed
+    assert n_passes <= max_repeats
+    n_failures = max_repeats - n_passes
+    L.info("Test has FAILed despite all repetitions! re-runs:%d failures:%d",
+           max_repeats, n_failures)
+    return False
+
+
+def main():
+    args = parse_args()
+    n_full_runs = 1 if args.parse_xml_testlog else 2
+
+    for i in range(n_full_runs + 1):
+
+        if 0 < i < n_full_runs:
+            L.info("Will re-run the full test executable")
+        elif i == n_full_runs:    # Failed on the final run
+            L.error("Full test run failed repeatedly, aborting!")
+            sys.exit(3)
+
+        try:
+            failed_functions = []
+            if args.parse_xml_testlog:      # do not run test, just parse file
+                failed_functions = parse_log(args.parse_xml_testlog)
+                # Pretend the test returned correct exit code
+                retcode = len(failed_functions)
+            else:                                # normal invocation, run test
+                (retcode, results_file) = \
+                    run_full_test(args.test_basename, args.testargs, args.log_dir,
+                                  args.no_extra_args, args.dry_run, args.timeout,
+                                  args.specific_extra_args)
+                if results_file:
+                    failed_functions = parse_log(results_file)
+
+            if retcode == 0:
+                if failed_functions:
+                    L.warning("The test executable returned success but the logfile"
+                             f" contains FAIL for function: {failed_functions[0].func}")
+                    continue
+                sys.exit(0)    # PASS
+
+            if len(failed_functions) == 0:
+                L.warning("No failures listed in the XML test log!"
+                          " Did the test CRASH right after all its testcases PASSed?")
+                continue
+
+            cant_rerun = [ f.func for f in failed_functions if f.func in NO_RERUN_FUNCTIONS ]
+            if cant_rerun:
+                L.warning(f"Failure detected in the special test function '{cant_rerun[0]}'"
+                          " which can not be re-run individually")
+                continue
+
+            assert len(failed_functions) > 0  and  retcode != 0
+            break    # all is fine, goto re-running individual failed testcases
+
+        except Exception as e:
+            L.error("exception:%s %s", type(e).__name__, e)
+            L.error("The test executable probably crashed, see above for details")
+
+    if args.max_repeats == 0:
+        sys.exit(2)          # Some tests failed but no re-runs were asked
+
+    L.info("Some tests failed, will re-run at most %d times.\n",
+           args.max_repeats)
+
+    for what_failed in failed_functions:
+        try:
+            ret = rerun_failed_testcase(args.test_basename, args.testargs, args.log_dir,
+                                        what_failed, args.max_repeats, args.passes_needed,
+                                        dryrun=args.dry_run, timeout=args.timeout)
+        except Exception as e:
+            L.error("exception:%s %s", type(e).__name__, e)
+            L.error("The testcase re-run probably crashed, giving up")
+            sys.exit(3)                                    # Test re-run CRASH
+
+        if not ret:
+            sys.exit(2)                                    # Test re-run FAIL
+
+    sys.exit(0)                                  # All testcase re-runs PASSed
+
+
+if __name__ == "__main__":
+    main()

qt/6.8.1/msvc2022_64/bin/qt.conf

@@ -0,0 +1,2 @@
+[Paths]
+Prefix=..

qt/6.8.1/msvc2022_64/bin/qtenv2.bat

@@ -0,0 +1,5 @@
+@echo off
+echo Setting up environment for Qt usage...
+set PATH=D:\code\apps\devtools\qt\6.8.1\msvc2022_64\bin;%PATH%
+cd /D D:\code\apps\devtools\qt\6.8.1\msvc2022_64
+echo Remember to call vcvarsall.bat to complete environment setup!

qt/6.8.1/msvc2022_64/bin/sanitizer-testrunner.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+import os
+import re
+import sys
+import logging as L
+from subprocess import Popen, PIPE
+
+
+# Thin testrunner that ignores failures in tests and only catches
+# crashes or ASAN errors.
+#
+# It executes its arguments as a command line, and parses the stderr for the
+# following regex:
+detect_ASAN = re.compile(r"^==[0-9]+==ERROR: AddressSanitizer")
+
+
+my_name = os.path.basename(sys.argv[0])
+logging_format = my_name + " %(levelname)8s: %(message)s"
+L.basicConfig(format=logging_format, level=L.DEBUG)
+
+L.info("This test is wrapped with sanitizer-testrunner.py. FAIL results are being ignored! Only crashes and ASAN errors are caught.")
+
+proc = None
+if sys.argv[1] == "-f":            # hidden option to parse pre-existing files
+    f = open(sys.argv[2], "r", errors="ignore")
+else:
+    proc = Popen(sys.argv[1:], stderr=PIPE, universal_newlines=True, errors="ignore")
+    f = proc.stderr
+
+issues_detected = False
+for line in f:
+    if proc:
+        # We don't want the stderr of the subprocess to disappear, so print it.
+        print(line, file=sys.stderr, end="", flush=True)
+    if detect_ASAN.match(line):
+        issues_detected = True
+f.close()
+if proc:
+    proc.wait()
+    rc = proc.returncode
+    L.info("Test exit code was: %d", rc)
+    if not ( 0 <= rc <= 127 ):
+        L.error("Crash detected")
+        exit(1)
+
+if issues_detected:
+    L.error("ASAN issues detected")
+    exit(1)