mqt-core 3.1.0__cp313-cp313-win_arm64.whl

mqt/core/plugins/qiskit/qiskit_to_mqt.py

@@ -0,0 +1,455 @@
+# Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+# Copyright (c) 2025 Munich Quantum Software Company GmbH
+# All rights reserved.
+#
+# SPDX-License-Identifier: MIT
+#
+# Licensed under the MIT License
+
+"""Functionality for translating from Qiskit to the MQT."""
+
+from __future__ import annotations
+
+import re
+import warnings
+from typing import TYPE_CHECKING, cast
+
+from qiskit.circuit import AncillaRegister, Clbit, Qubit
+
+from ...ir import QuantumComputation
+from ...ir.operations import (
+    CompoundOperation,
+    Control,
+    NonUnitaryOperation,
+    OpType,
+    StandardOperation,
+    SymbolicOperation,
+)
+from ...ir.symbolic import Expression, Term, Variable
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping, Sequence
+
+    from qiskit.circuit import Instruction, ParameterExpression, QuantumCircuit
+
+
+__all__ = ["qiskit_to_mqt"]
+
+
+def __dir__() -> list[str]:
+    return __all__
+
+
+def qiskit_to_mqt(circ: QuantumCircuit) -> QuantumComputation:
+    """Convert a Qiskit :class:`~qiskit.circuit.QuantumCircuit` to a :class:`~mqt.core.ir.QuantumComputation` object.
+
+    Args:
+        circ: The Qiskit circuit to convert.
+
+    Returns:
+        The converted circuit.
+    """
+    qc = QuantumComputation()
+
+    if circ.name is not None:
+        qc.name = circ.name
+
+    qubit_index = 0
+    qubit_map: dict[Qubit, int] = {}
+    for reg in circ.qregs:
+        size = reg.size
+        if size == 0:
+            continue
+        if isinstance(reg, AncillaRegister):
+            qc.add_ancillary_register(size, reg.name)
+        else:
+            qc.add_qubit_register(size, reg.name)
+        for qubit in reg:
+            qubit_map[qubit] = qubit_index
+            qubit_index += 1
+
+    clbit_index = 0
+    clbit_map: dict[Clbit, int] = {}
+    for reg in circ.cregs:
+        size = reg.size
+        if size == 0:
+            continue
+        qc.add_classical_register(size, reg.name)
+        for bit in reg:
+            clbit_map[bit] = clbit_index
+            clbit_index += 1
+
+    try:
+        qc.global_phase = circ.global_phase
+    except TypeError:
+        warnings.warn(
+            "Symbolic global phase values are not supported yet. Setting global phase to 0.",
+            RuntimeWarning,
+            stacklevel=2,
+        )
+        qc.global_phase = 0
+
+    for instruction in circ.data:
+        symb_params = _emplace_operation(
+            qc,
+            instruction.operation,
+            instruction.qubits,
+            instruction.clbits,
+            instruction.operation.params,
+            qubit_map,
+            clbit_map,
+        )
+        for symb_param in symb_params:
+            qc.add_variable(symb_param)
+
+    # import initial layout and output permutation if available
+    if circ.layout is not None:
+        _import_layouts(qc, circ)
+
+    qc.initialize_io_mapping()
+    return qc
+
+
+_NATIVELY_SUPPORTED_GATES = frozenset({
+    "i",
+    "id",
+    "iden",
+    "x",
+    "y",
+    "z",
+    "h",
+    "s",
+    "sdg",
+    "t",
+    "tdg",
+    "p",
+    "u1",
+    "rx",
+    "ry",
+    "rz",
+    "u2",
+    "u",
+    "u3",
+    "cx",
+    "cy",
+    "cz",
+    "cs",
+    "csdg",
+    "cp",
+    "cu1",
+    "ch",
+    "crx",
+    "cry",
+    "crz",
+    "cu3",
+    "ccx",
+    "swap",
+    "cswap",
+    "iswap",
+    "sx",
+    "sxdg",
+    "csx",
+    "mcx",
+    # we keep the "mcx_*" variants here for compatibility with Qiskit 1.x
+    "mcx_gray",
+    "mcx_recursive",
+    "mcx_vchain",
+    "mcphase",
+    "mcrx",
+    "mcry",
+    "mcrz",
+    "dcx",
+    "ecr",
+    "rxx",
+    "ryy",
+    "rzx",
+    "rzz",
+    "xx_minus_yy",
+    "xx_plus_yy",
+    "reset",
+    "barrier",
+    "measure",
+})
+
+
+def _emplace_operation(
+    qc: QuantumComputation | CompoundOperation,
+    instr: Instruction,
+    qargs: Sequence[Qubit],
+    cargs: Sequence[Clbit],
+    params: Sequence[float | ParameterExpression],
+    qubit_map: Mapping[Qubit, int],
+    clbit_map: Mapping[Clbit, int],
+) -> list[float | ParameterExpression]:
+    name = instr.name
+
+    if name not in _NATIVELY_SUPPORTED_GATES:
+        try:
+            return _import_definition(qc, instr.definition, qargs, cargs, qubit_map, clbit_map)
+        except Exception as ex:  # PRAGMA: NO COVER
+            msg = f"Unsupported gate {name} with definition {instr.definition}"
+            raise NotImplementedError(msg) from ex
+
+    qubits = [qubit_map[qubit] for qubit in qargs]
+
+    if name == "measure":
+        clbits = [clbit_map[clbit] for clbit in cargs]
+        qc.append(NonUnitaryOperation(qubits, clbits))
+        return []
+
+    if name == "reset":
+        qc.append(NonUnitaryOperation(qubits))
+        return []
+
+    if name == "barrier":
+        qc.append(StandardOperation(qubits, OpType.barrier))
+        return []
+
+    if name in {"i", "id", "iden"}:
+        return _add_operation(qc, OpType.i, qargs, params, qubit_map)
+
+    # we keep "mcx_gray" here for compatibility reasons with older Qiskit versions, e.g., 1.0.0 where "noancilla"
+    # is the default for the argument "mode" which leads to the gate name "gray_code"
+    if name in {"x", "cx", "ccx", "mcx", "mcx_gray"}:
+        return _add_operation(qc, OpType.x, qargs, params, qubit_map)
+
+    if name in {"y", "cy"}:
+        return _add_operation(qc, OpType.y, qargs, params, qubit_map)
+
+    if name in {"z", "cz"}:
+        return _add_operation(qc, OpType.z, qargs, params, qubit_map)
+
+    if name in {"h", "ch"}:
+        return _add_operation(qc, OpType.h, qargs, params, qubit_map)
+
+    if name in {"s", "cs"}:
+        return _add_operation(qc, OpType.s, qargs, params, qubit_map)
+
+    if name in {"sdg", "csdg"}:
+        return _add_operation(qc, OpType.sdg, qargs, params, qubit_map)
+
+    if name == "t":
+        return _add_operation(qc, OpType.t, qargs, params, qubit_map)
+
+    if name == "tdg":
+        return _add_operation(qc, OpType.tdg, qargs, params, qubit_map)
+
+    if name in {"sx", "csx"}:
+        return _add_operation(qc, OpType.sx, qargs, params, qubit_map)
+
+    if name == "sxdg":
+        return _add_operation(qc, OpType.sxdg, qargs, params, qubit_map)
+
+    if name == "mcx_recursive":
+        if len(qargs) <= 5:
+            return _add_operation(qc, OpType.x, qargs, params, qubit_map)
+        # reconfigure controls and targets (drops the last qubit as ancilla)
+        qargs = qargs[:-1]
+        return _add_operation(qc, OpType.x, qargs, params, qubit_map)
+
+    if name == "mcx_vchain":
+        size = len(qargs)
+        num_controls = (size + 1) // 2
+        # reconfigure controls and targets (drops the last num_controls - 2 qubits as ancilla)
+        if num_controls > 2:
+            qargs = qargs[: -num_controls + 2]
+        return _add_operation(qc, OpType.x, qargs, params, qubit_map)
+
+    if name in {"rx", "crx", "mcrx"}:
+        return _add_operation(qc, OpType.rx, qargs, params, qubit_map)
+
+    if name in {"ry", "cry", "mcry"}:
+        return _add_operation(qc, OpType.ry, qargs, params, qubit_map)
+
+    if name in {"rz", "crz", "mcrz"}:
+        return _add_operation(qc, OpType.rz, qargs, params, qubit_map)
+
+    if name in {"p", "u1", "cp", "cu1", "mcphase"}:
+        return _add_operation(qc, OpType.p, qargs, params, qubit_map)
+
+    if name == "u2":
+        return _add_operation(qc, OpType.u2, qargs, params, qubit_map)
+
+    if name in {"u", "u3", "cu3"}:
+        return _add_operation(qc, OpType.u, qargs, params, qubit_map)
+
+    if name in {"swap", "cswap"}:
+        return _add_two_target_operation(qc, OpType.swap, qargs, params, qubit_map)
+
+    if name == "iswap":
+        return _add_two_target_operation(qc, OpType.iswap, qargs, params, qubit_map)
+
+    if name == "dcx":
+        return _add_two_target_operation(qc, OpType.dcx, qargs, params, qubit_map)
+
+    if name == "ecr":
+        return _add_two_target_operation(qc, OpType.ecr, qargs, params, qubit_map)
+
+    if name == "rxx":
+        return _add_two_target_operation(qc, OpType.rxx, qargs, params, qubit_map)
+
+    if name == "ryy":
+        return _add_two_target_operation(qc, OpType.ryy, qargs, params, qubit_map)
+
+    if name == "rzz":
+        return _add_two_target_operation(qc, OpType.rzz, qargs, params, qubit_map)
+
+    if name == "rzx":
+        return _add_two_target_operation(qc, OpType.rzx, qargs, params, qubit_map)
+
+    if name == "xx_minus_yy":
+        return _add_two_target_operation(qc, OpType.xx_minus_yy, qargs, params, qubit_map)
+
+    if name == "xx_plus_yy":
+        return _add_two_target_operation(qc, OpType.xx_plus_yy, qargs, params, qubit_map)
+
+    msg = f"Unsupported gate {name}"  # pragma: no cover
+    raise NotImplementedError(msg)
+
+
+_SUM_REGEX = re.compile(r"[+|-]?[^+-]+")
+_PROD_REGEX = re.compile(r"[*/]?[^*/]+")
+
+
+def _parse_symbolic_expression(qiskit_expr: ParameterExpression | float) -> float | Expression:
+    if isinstance(qiskit_expr, float):
+        return qiskit_expr
+
+    expr_str = str(qiskit_expr).strip()
+    expr = Expression()
+    is_const = True
+    for summand in _SUM_REGEX.findall(expr_str):
+        sign = 1
+        summand_no_operator = summand
+        if summand[0] == "+":
+            summand_no_operator = summand[1:]
+        elif summand[0] == "-":
+            summand_no_operator = summand[1:]
+            sign = -1
+
+        coeff = 1.0
+        var = ""
+        for factor in _PROD_REGEX.findall(summand_no_operator):
+            is_div = False
+            factor_no_operator = factor
+            if factor[0] == "*":
+                factor_no_operator = factor[1:]
+            elif factor[0] == "/":
+                factor_no_operator = factor[1:]
+                is_div = True
+
+            factor_no_operator = factor_no_operator.strip()
+            if factor_no_operator.replace(".", "").isnumeric():
+                f = float(factor_no_operator)
+                coeff *= 1.0 / f if is_div else f
+            else:
+                var = factor_no_operator
+
+        if not var:
+            expr += coeff
+        else:
+            is_const = False
+            expr += Term(Variable(var), sign * coeff)
+
+    if is_const:
+        return expr.constant
+    return expr
+
+
+def _add_operation(
+    qc: QuantumComputation | CompoundOperation,
+    type_: OpType,
+    qargs: Sequence[Qubit],
+    params: Sequence[float | ParameterExpression],
+    qubit_map: Mapping[Qubit, int],
+) -> list[float | ParameterExpression]:
+    qubits = [qubit_map[qubit] for qubit in qargs]
+    target = qubits.pop()
+    controls = {Control(qubit) for qubit in qubits}
+    parameters = [_parse_symbolic_expression(param) for param in params]
+    if any(isinstance(parameter, Expression) for parameter in parameters):
+        qc.append(SymbolicOperation(controls, target, type_, parameters))
+    else:
+        qc.append(StandardOperation(controls, target, type_, cast("list[float]", parameters)))
+    return parameters
+
+
+def _add_two_target_operation(
+    qc: QuantumComputation | CompoundOperation,
+    type_: OpType,
+    qargs: Sequence[Qubit],
+    params: Sequence[float | ParameterExpression],
+    qubit_map: Mapping[Qubit, int],
+) -> list[float | ParameterExpression]:
+    qubits = [qubit_map[qubit] for qubit in qargs]
+    target2 = qubits.pop()
+    target1 = qubits.pop()
+    controls = {Control(qubit) for qubit in qubits}
+    parameters = [_parse_symbolic_expression(param) for param in params]
+    if any(isinstance(parameter, Expression) for parameter in parameters):
+        qc.append(SymbolicOperation(controls, target1, target2, type_, parameters))
+    else:
+        qc.append(StandardOperation(controls, target1, target2, type_, cast("list[float]", parameters)))
+    return parameters
+
+
+def _import_layouts(qc: QuantumComputation, circ: QuantumCircuit) -> None:
+    qc.initial_layout.clear()
+    initial_index_layout = circ.layout.initial_index_layout()
+    for virtual, physical in enumerate(initial_index_layout):
+        qc.initial_layout[physical] = virtual
+
+    # Properly mark ancillary qubits
+    for register in circ.layout.initial_layout.get_registers():
+        if register.name != "ancilla" and not isinstance(register, AncillaRegister):
+            continue
+        for qubit in reversed(register):
+            physical_qubit = circ.layout.initial_layout[qubit]
+            virtual_qubit = qc.initial_layout[physical_qubit]
+            qc.set_circuit_qubit_ancillary(virtual_qubit)
+
+    if circ.layout.final_layout is None:
+        qc.output_permutation = qc.initial_layout
+        return
+
+    qc.output_permutation.clear()
+    final_index_layout = circ.layout.final_index_layout()
+    for virtual, physical in enumerate(final_index_layout):
+        qc.output_permutation[physical] = virtual
+
+    # Properly mark garbage qubits
+    # Any qubit in the initial layout that is not in the final layout is garbage
+    for virtual_qubit in range(len(final_index_layout), len(initial_index_layout)):
+        qc.set_circuit_qubit_garbage(virtual_qubit)
+
+
+def _import_definition(
+    qc: QuantumComputation | CompoundOperation,
+    circ: QuantumCircuit,
+    qargs: Sequence[Qubit],
+    cargs: Sequence[Clbit],
+    qubit_map: Mapping[Qubit, int],
+    clbit_map: Mapping[Clbit, int],
+) -> list[float | ParameterExpression]:
+    qarg_map = dict(zip(circ.qubits, qargs))
+    carg_map = dict(zip(circ.clbits, cargs))
+
+    qc.append(CompoundOperation())
+    comp_op = cast("CompoundOperation", qc[-1])
+
+    params = []
+    for instruction in circ.data:
+        mapped_qargs = [qarg_map[qarg] for qarg in instruction.qubits]
+        mapped_cargs = [carg_map[carg] for carg in instruction.clbits]
+        operation = instruction.operation
+        new_params = _emplace_operation(
+            comp_op,
+            operation,
+            mapped_qargs,
+            mapped_cargs,
+            operation.params,
+            qubit_map,
+            clbit_map,
+        )
+        params.extend(new_params)
+    return params

mqt/core/py.typed

@@ -0,0 +1,2 @@
+# Instruct type checkers to look for inline type annotations in this package.
+# See PEP 561.

mqt/core/share/cmake/mqt-core/AddMQTPythonBinding.cmake

@@ -0,0 +1,52 @@
+# Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+# Copyright (c) 2025 Munich Quantum Software Company GmbH
+# All rights reserved.
+#
+# SPDX-License-Identifier: MIT
+#
+# Licensed under the MIT License
+
+function(add_mqt_python_binding package_name target_name)
+  # parse the arguments
+  cmake_parse_arguments(ARG "" "MODULE_NAME;INSTALL_DIR" "LINK_LIBS" ${ARGN})
+  set(SOURCES ${ARG_UNPARSED_ARGUMENTS})
+
+  # declare the Python module
+  pybind11_add_module(
+    # name of the extension
+    ${target_name}
+    # Pprefer thin LTO if available
+    THIN_LTO
+    # optimize the bindings for size
+    OPT_SIZE
+    # source code goes here
+    ${SOURCES})
+
+  # set default "." for INSTALL_DIR
+  if(NOT ARG_INSTALL_DIR)
+    set(ARG_INSTALL_DIR ".")
+  endif()
+
+  if(ARG_MODULE_NAME)
+    # the library name must be the same as the module name
+    set_target_properties(${target_name} PROPERTIES OUTPUT_NAME ${ARG_MODULE_NAME})
+    target_compile_definitions(${target_name}
+                               PRIVATE MQT_${package_name}_MODULE_NAME=${ARG_MODULE_NAME})
+  else()
+    # use the target name as the module name
+    target_compile_definitions(${target_name}
+                               PRIVATE MQT_${package_name}_MODULE_NAME=${target_name})
+  endif()
+
+  # add project libraries to the link libraries
+  list(APPEND ARG_LINK_LIBS MQT::ProjectOptions MQT::ProjectWarnings)
+
+  # link the required libraries
+  target_link_libraries(${target_name} PRIVATE ${ARG_LINK_LIBS})
+
+  # install directive for scikit-build-core
+  install(
+    TARGETS ${target_name}
+    DESTINATION ${ARG_INSTALL_DIR}
+    COMPONENT ${MQT_${package_name}_TARGET_NAME}_Python)
+endfunction()

mqt/core/share/cmake/mqt-core/Cache.cmake

@@ -0,0 +1,32 @@
+# Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+# Copyright (c) 2025 Munich Quantum Software Company GmbH
+# All rights reserved.
+#
+# SPDX-License-Identifier: MIT
+#
+# Licensed under the MIT License
+
+option(ENABLE_CACHE "Enable compiler cache if available" ON)
+if(NOT ENABLE_CACHE)
+  return()
+endif()
+
+set(CACHE_OPTION_VALUES "ccache" "sccache")
+set(CACHE_OPTION
+    "ccache"
+    CACHE STRING "Compiler cache to use")
+set_property(CACHE CACHE_OPTION PROPERTY STRINGS ${CACHE_OPTION_VALUES})
+list(FIND CACHE_OPTION_VALUES ${CACHE_OPTION} CACHE_OPTION_INDEX)
+if(CACHE_OPTION_INDEX EQUAL -1)
+  message(NOTICE
+          "Unknown compiler cache '${CACHE_OPTION}'. Available options are: ${CACHE_OPTION_VALUES}")
+endif()
+
+find_program(CACHE_BINARY ${CACHE_OPTION})
+if(CACHE_BINARY)
+  message(STATUS "Compiler cache '${CACHE_OPTION}' found and enabled")
+  set(CMAKE_C_COMPILER_LAUNCHER ${CACHE_BINARY})
+  set(CMAKE_CXX_COMPILER_LAUNCHER ${CACHE_BINARY})
+else()
+  message(NOTICE "${CACHE_OPTION} is enabled but was not found. Not using it")
+endif()

mqt/core/share/cmake/mqt-core/FindGMP.cmake

@@ -0,0 +1,103 @@
+# Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+# Copyright (c) 2025 Munich Quantum Software Company GmbH
+# All rights reserved.
+#
+# SPDX-License-Identifier: MIT
+#
+# Licensed under the MIT License
+
+# File adapted from
+# https://github.com/dune-project/dune-common/blob/master/cmake/modules/FindGMP.cmake
+
+#[=======================================================================[.rst:
+FindGMP
+-------
+
+Find the GNU MULTI-Precision Bignum (GMP) library
+and the corresponding C++ bindings GMPxx.
+
+This module searches for both libraries and only considers the package
+found if both can be located. It then defines separate targets for the C
+and the C++ library.
+
+Imported Targets
+^^^^^^^^^^^^^^^^
+
+This module provides the following imported targets, if found:
+
+``GMP::gmp``
+  Library target of the C library.
+``GMP::gmpxx``
+  Library target of the C++ library, which also links to the C library.
+
+Result Variables
+^^^^^^^^^^^^^^^^
+
+This will define the following variables:
+
+``GMP_FOUND``
+  True if the GMP library, the GMPxx headers and
+  the GMPxx library were found.
+
+Cache Variables
+^^^^^^^^^^^^^^^
+
+You may set the following variables to modify the behaviour of
+this module:
+
+``GMP_INCLUDE_DIR``
+  The directory containing ``gmp.h``.
+``GMP_LIB``
+  The path to the gmp library.
+``GMPXX_INCLUDE_DIR``
+  The directory containing ``gmpxx.h``.
+``GMPXX_LIB``
+  The path to the gmpxx library.
+
+#]=======================================================================]
+
+# Add a feature summary for this package
+include(FeatureSummary)
+set_package_properties(
+  GMP PROPERTIES
+  DESCRIPTION "GNU multi-precision library"
+  URL "https://gmplib.org")
+
+# Try finding the package with pkg-config
+find_package(PkgConfig QUIET)
+pkg_check_modules(PKG QUIET gmp gmpxx)
+
+# Try to locate the libraries and their headers, using pkg-config hints
+find_path(GMP_INCLUDE_DIR gmp.h HINTS ${PKG_gmp_INCLUDEDIR})
+find_library(GMP_LIB gmp HINTS ${PKG_gmp_LIBDIR})
+
+find_path(GMPXX_INCLUDE_DIR gmpxx.h HINTS ${PKG_gmpxx_INCLUDEDIR})
+find_library(GMPXX_LIB gmpxx HINTS ${PKG_gmpxx_LIBDIR})
+
+# Remove these variables from cache inspector
+mark_as_advanced(GMP_INCLUDE_DIR GMP_LIB GMPXX_INCLUDE_DIR GMPXX_LIB)
+
+# Report if package was found
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(GMP DEFAULT_MSG GMPXX_LIB GMPXX_INCLUDE_DIR GMP_INCLUDE_DIR
+                                  GMP_LIB)
+
+# Set targets
+if(GMP_FOUND)
+  # C library
+  if(NOT TARGET GMP::gmp)
+    add_library(GMP::gmp UNKNOWN IMPORTED)
+    set_target_properties(GMP::gmp PROPERTIES IMPORTED_LOCATION ${GMP_LIB}
+                                              INTERFACE_INCLUDE_DIRECTORIES ${GMP_INCLUDE_DIR})
+  endif()
+
+  # C++ library, which requires a link to the C library
+  if(NOT TARGET GMP::gmpxx)
+    add_library(GMP::gmpxx UNKNOWN IMPORTED)
+    set_target_properties(
+      GMP::gmpxx
+      PROPERTIES IMPORTED_LOCATION ${GMPXX_LIB}
+                 INTERFACE_INCLUDE_DIRECTORIES ${GMPXX_INCLUDE_DIR}
+                 INTERFACE_LINK_LIBRARIES GMP::gmp)
+  endif()
+endif()

mqt/core/share/cmake/mqt-core/PackageAddTest.cmake

@@ -0,0 +1,40 @@
+# Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+# Copyright (c) 2025 Munich Quantum Software Company GmbH
+# All rights reserved.
+#
+# SPDX-License-Identifier: MIT
+#
+# Licensed under the MIT License
+
+# macro to add a test executable for one of the project libraries
+macro(PACKAGE_ADD_TEST testname linklibs)
+  if(NOT TARGET ${testname})
+    # create an executable in which the tests will be stored
+    add_executable(${testname} ${ARGN})
+    # link the Google test infrastructure and a default main function to the test executable.
+    target_link_libraries(${testname} PRIVATE ${linklibs} GTest::gmock GTest::gtest_main
+                                              MQT::ProjectOptions MQT::ProjectWarnings)
+    # discover tests
+    gtest_discover_tests(
+      ${testname}
+      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+      PROPERTIES VS_DEBUGGER_WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" DISCOVERY_TIMEOUT 60)
+    set_target_properties(${testname} PROPERTIES FOLDER tests)
+  endif()
+endmacro()
+
+macro(PACKAGE_ADD_TEST_WITH_WORKING_DIR testname linklibs test_working_directory)
+  if(NOT TARGET ${testname})
+    # create an executable in which the tests will be stored
+    add_executable(${testname} ${ARGN})
+    # link the Google test infrastructure and a default main function to the test executable.
+    target_link_libraries(${testname} PRIVATE ${linklibs} GTest::gmock GTest::gtest_main
+                                              MQT::ProjectOptions MQT::ProjectWarnings)
+    # discover tests
+    gtest_discover_tests(
+      ${testname}
+      WORKING_DIRECTORY ${test_working_directory}
+      PROPERTIES VS_DEBUGGER_WORKING_DIRECTORY "${test_working_directory}" DISCOVERY_TIMEOUT 60)
+    set_target_properties(${testname} PROPERTIES FOLDER tests)
+  endif()
+endmacro()