spl-core 4.0.0__py3-none-any.whl

spl_core/__init__.py

@@ -0,0 +1 @@
+__version__ = "4.0.0"

spl_core/common/cmake.py

@@ -0,0 +1,52 @@
+import logging
+import subprocess
+from subprocess import CompletedProcess
+
+from spl_core.project_creator.variant import Variant
+from spl_core.project_creator.workspace_artifacts import WorkspaceArtifacts
+
+
+class CMake:
+    executable = "cmake"
+
+    def __init__(self, workspace_artifacts: WorkspaceArtifacts):
+        self.logger = logging.getLogger(__name__)
+        self.workspace_artifacts = workspace_artifacts
+
+    def run(self, variant: Variant, build_kit: str = "prod", target: str = "all") -> CompletedProcess[bytes]:
+        ret_status = self.configure(variant, build_kit)
+        if ret_status.returncode == 0:
+            ret_status = self.build(variant, build_kit, target)
+        return ret_status
+
+    def configure(self, variant: Variant, build_kit: str = "prod") -> CompletedProcess[bytes]:
+        arguments = (
+            f" --log-level=DEBUG"
+            f" -S{self.workspace_artifacts.root_dir}"
+            f" -B{self.workspace_artifacts.get_build_dir(variant, build_kit)}"
+            f" -G Ninja "
+            f" -DBUILD_KIT:STRING={build_kit}"
+            f" -DVARIANT:STRING={variant.to_string()}"
+            f" -DCMAKE_BUILD_TYPE:STRING={variant.to_string('_')}"
+        )
+        if build_kit == "test":
+            toolchain = self.workspace_artifacts.root_dir.joinpath(
+                "tools\\toolchains\\gcc\\toolchain.cmake"
+            )
+            arguments += f" -DCMAKE_TOOLCHAIN_FILE={toolchain}"
+        return self.run_cmake(arguments)
+
+    def build(
+        self, variant: Variant, build_kit: str = "prod", target: str = "all"
+    ) -> CompletedProcess[bytes]:
+        arguments = (
+            f" --build {self.workspace_artifacts.get_build_dir(variant, build_kit)}"
+            f" --config {variant.to_string('_')}"
+            f" --target {target} -- "
+        )
+        return self.run_cmake(arguments)
+
+    def run_cmake(self, arguments: str) -> CompletedProcess[bytes]:
+        command = self.executable + " " + arguments
+        print(f"Running {command}")
+        return subprocess.run(command.split())

spl_core/common/path.py

@@ -0,0 +1,17 @@
+from pathlib import Path
+
+
+def to_path(input_path: str, check_if_exists: bool = True) -> Path:
+    return_path = Path(input_path)
+    if not check_if_exists or return_path.exists():
+        return return_path.absolute()
+    else:
+        raise FileNotFoundError(input_path)
+
+
+def existing_path(input_path: str) -> Path:
+    return to_path(input_path, True)
+
+
+def non_existing_path(input_path: str) -> Path:
+    return to_path(input_path, False)

spl_core/gcov_maid/gcov_maid.py

@@ -0,0 +1,48 @@
+import argparse
+from pathlib import Path
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Script with command line options")
+    parser.add_argument(
+        "--working-dir", help="Working directory", required=True
+    )  # Make the option mandatory
+    parser.add_argument(
+        "--wipe-all-gcda", action="store_true", help="Wipe all gcda files recursively"
+    )
+    parser.add_argument(
+        "--wipe-orphaned-gcno",
+        action="store_true",
+        help="Wipe orphaned gcno files recursively",
+    )
+
+    args = parser.parse_args()
+
+    # Access the command line options
+    working_dir = Path(args.working_dir)  # Convert the string to a Path object
+    wipe_gcda = bool(args.wipe_all_gcda)  # Convert the switch value to boolean
+    wipe_gcno = bool(args.wipe_orphaned_gcno)  # Convert the switch value to boolean
+
+    if wipe_gcda:
+        wipe_gcda_files(working_dir)
+
+    if wipe_gcno:
+        wipe_gcno_files(working_dir)
+
+
+def wipe_gcda_files(working_dir: Path) -> None:
+    for file in working_dir.glob("**/*.gcda"):
+        print(f"Deleting obsolete coverage data file: {file}")
+        file.unlink()
+
+
+def wipe_gcno_files(working_dir: Path) -> None:
+    for file in working_dir.glob("**/*.gcno"):
+        obj_file = file.with_suffix(".obj")
+        if not obj_file.exists():
+            print(f"Deleting obsolete coverage notes file: {file}")
+            file.unlink()
+
+
+if __name__ == "__main__":
+    main()

spl_core/kconfig/kconfig.py

@@ -0,0 +1,271 @@
+import argparse
+import json
+import os
+import re
+from abc import ABC, abstractmethod
+from contextlib import contextmanager
+from dataclasses import dataclass
+from enum import Enum, auto
+from pathlib import Path
+from typing import Any, Generator, List, Optional
+
+import kconfiglib
+
+from spl_core.common.path import existing_path, non_existing_path
+
+
+class GeneratedFile:
+    def __init__(self, path: Path, content: str = "", skip_writing_if_unchanged: bool = False) -> None:
+        self.path = path
+
+        self.content = content
+
+        self.skip_writing_if_unchanged = skip_writing_if_unchanged
+
+    def to_string(self) -> str:
+        return self.content
+
+    def to_file(self) -> None:
+        """
+        Only write to file if the content has changed.
+
+        The directory of the file is created if it does not exist.
+        """
+        content = self.to_string()
+
+        if not self.path.exists() or not self.skip_writing_if_unchanged or self.path.read_text() != content:
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            self.path.write_text(content)
+
+
+class TriState(Enum):
+    Y = auto()
+    M = auto()
+    N = auto()
+
+
+class ConfigElementType(Enum):
+    UNKNOWN = auto()
+    BOOL = auto()
+    TRISTATE = auto()
+    STRING = auto()
+    INT = auto()
+    HEX = auto()
+
+
+@dataclass
+class ConfigElement:
+    type: ConfigElementType
+    name: str
+    value: Any
+    #: Is determined when the value is calculated. This is a hidden function call due to property magic.
+    _write_to_conf: bool = True
+
+
+@dataclass
+class ConfigurationData:
+    """
+    - holds the variant configuration data
+    - requires no variable substitution (this should have been already done)
+    """
+
+    elements: List[ConfigElement]
+
+
+class FileWriter(ABC):
+    """- writes the ConfigurationData to a file"""
+
+    def __init__(self, output_file: Path):
+        self.output_file = output_file
+
+    def write(self, configuration_data: ConfigurationData) -> None:
+        """
+        - writes the ConfigurationData to a file
+        The file shall not be modified if the content is the same as the existing one
+        """
+        content = self.generate_content(configuration_data)
+        GeneratedFile(self.output_file, content, skip_writing_if_unchanged=True).to_file()
+
+    @abstractmethod
+    def generate_content(self, configuration_data: ConfigurationData) -> str:
+        """- generates the content of the file from the ConfigurationData"""
+
+
+class HeaderWriter(FileWriter):
+    """Writes the ConfigurationData as pre-processor defines in a C Header file"""
+
+    config_prefix = "CONFIG_"  # Prefix for all configuration defines
+
+    def generate_content(self, configuration_data: ConfigurationData) -> str:
+        """
+        This method does exactly what the kconfiglib.write_autoconf() method does.
+        We had to implemented here because we refactor the file writers to use the ConfigurationData
+        instead of the KConfig configuration. ConfigurationData has variable substitution already done.
+        """
+        result: List[str] = [
+            "/** @file */",
+            "#ifndef __autoconf_h__",
+            "#define __autoconf_h__",
+            "",
+        ]
+
+        def add_define(define_decl: str, description: str) -> None:
+            result.append(f"/** {description} */")
+            result.append(define_decl)
+
+        for element in configuration_data.elements:
+            val = element.value
+            if not element._write_to_conf:
+                continue
+
+            if element.type in [ConfigElementType.BOOL, ConfigElementType.TRISTATE]:
+                if val == TriState.Y:
+                    add_define(f"#define {self.config_prefix}{element.name} 1", element.name)
+                elif val == TriState.M:
+                    add_define(
+                        f"#define {self.config_prefix}{element.name}_MODULE 1",
+                        element.name,
+                    )
+
+            elif element.type is ConfigElementType.STRING:
+                add_define(
+                    f'#define {self.config_prefix}{element.name} "{kconfiglib.escape(val)}"',
+                    element.name,
+                )
+
+            else:  # element.type in [INT, HEX]:
+                if element.type is ConfigElementType.HEX:
+                    val = hex(val)
+                add_define(f"#define {self.config_prefix}{element.name} {val}", element.name)
+        result.extend(["", "#endif /* __autoconf_h__ */", ""])
+        return "\n".join(result)
+
+
+class JsonWriter(FileWriter):
+    """Writes the ConfigurationData in json format"""
+
+    def generate_content(self, configuration_data: ConfigurationData) -> str:
+        result = {}
+        for element in configuration_data.elements:
+            if element.type is ConfigElementType.BOOL:
+                result[element.name] = True if element.value == TriState.Y else False
+            else:
+                result[element.name] = element.value
+        return json.dumps({"features": result}, indent=4)
+
+
+class CMakeWriter(FileWriter):
+    """Writes the ConfigurationData as CMake variables"""
+
+    def generate_content(self, configuration_data: ConfigurationData) -> str:
+        result: List[str] = []
+        add = result.append
+        for element in configuration_data.elements:
+            val = element.value
+            if element.type is ConfigElementType.BOOL:
+                val = True if element.value == TriState.Y else False
+            if not element._write_to_conf:
+                continue
+            add(f'set({element.name} "{val}")')
+
+        return "\n".join(result)
+
+
+@contextmanager
+def working_directory(some_directory: Path) -> Generator[Any, Any, Any]:
+    current_directory = Path().absolute()
+    try:
+        os.chdir(some_directory)
+        yield
+    finally:
+        os.chdir(current_directory)
+
+
+class KConfig:
+    def __init__(
+        self,
+        k_config_model_file: Path,
+        k_config_file: Optional[Path] = None,
+        k_config_root_directory: Optional[Path] = None,
+    ):
+        """
+        :param k_config_model_file: Feature model definition (KConfig format)
+        :param k_config_file: User feature selection configuration file
+        :param k_config_root_directory: all paths for the included configuration paths shall be relative to this folder
+        """
+        if not k_config_model_file.exists():
+            raise FileNotFoundError(f"File {k_config_model_file} does not exist.")
+        with working_directory(k_config_root_directory or k_config_model_file.parent):
+            self._config = kconfiglib.Kconfig(k_config_model_file.absolute().as_posix())
+        if k_config_file:
+            if not k_config_file.exists():
+                raise FileNotFoundError(f"File {k_config_file} does not exist.")
+            self._config.load_config(k_config_file, replace=False)
+        self.config = self.create_config_data(self._config)
+
+    def create_config_data(self, config: kconfiglib.Kconfig) -> ConfigurationData:
+        """- creates the ConfigurationData from the KConfig configuration"""
+        elements = []
+        elements_dict = {}
+
+        def process_node(node: Any) -> None:
+            sym = node.item
+            if not isinstance(sym, kconfiglib.Symbol):
+                return
+
+            if sym.config_string:
+                val = sym.str_value
+                type = ConfigElementType.STRING
+                if sym.type in [kconfiglib.BOOL, kconfiglib.TRISTATE]:
+                    val = getattr(TriState, str(val).upper())
+                    type = ConfigElementType.BOOL if sym.type == kconfiglib.BOOL else ConfigElementType.TRISTATE
+                elif sym.type == kconfiglib.HEX:
+                    val = int(str(val), 16)
+                    type = ConfigElementType.HEX
+                elif sym.type == kconfiglib.INT:
+                    val = int(val)
+                    type = ConfigElementType.INT
+                new_element = ConfigElement(type, sym.name, val, sym._write_to_conf)
+                elements.append(new_element)
+                elements_dict[sym.name] = new_element
+
+        for n in config.node_iter(False):
+            process_node(n)
+
+        # replace text in KConfig with referenced variables (string type only)
+        # KConfig variables get replaced like: ${VARIABLE_NAME}, e.g. ${CONFIG_FOO}
+        for element in elements:
+            if element.type == ConfigElementType.STRING:
+                element.value = re.sub(
+                    r"\$\{([A-Za-z0-9_]+)\}",
+                    lambda m: str(elements_dict[m.group(1)].value),
+                    element.value,
+                )
+                element.value = re.sub(
+                    r"\$\{ENV:([A-Za-z0-9_]+)\}",
+                    lambda m: str(os.environ.get(m.group(1), "")),
+                    element.value,
+                )
+
+        return ConfigurationData(elements)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="KConfig generation")
+    parser.add_argument("--kconfig_model_file", required=True, type=existing_path)
+    parser.add_argument("--kconfig_config_file", required=False, type=existing_path)
+    parser.add_argument("--out_header_file", required=True, type=non_existing_path)
+    parser.add_argument("--out_json_file", required=False, type=non_existing_path)
+    parser.add_argument("--out_cmake_file", required=False, type=non_existing_path)
+    arguments = parser.parse_args()
+    config = KConfig(arguments.kconfig_model_file, arguments.kconfig_config_file).config
+
+    HeaderWriter(arguments.out_header_file).write(config)
+    if arguments.out_json_file:
+        JsonWriter(arguments.out_json_file).write(config)
+    if arguments.out_cmake_file:
+        CMakeWriter(arguments.out_cmake_file).write(config)
+
+
+if __name__ == "__main__":
+    main()

spl_core/project_creator/creator.py

@@ -0,0 +1,133 @@
+import argparse
+import logging
+import shutil
+from pathlib import Path
+from typing import Any, Dict, List
+
+from cookiecutter.main import cookiecutter
+
+from spl_core.common.path import existing_path
+from spl_core.project_creator.variant import Variant
+from spl_core.project_creator.workspace_artifacts import WorkspaceArtifacts
+
+
+class Creator:
+    def __init__(self, project_name: str, out_dir: Path):
+        self.logger = logging.getLogger(__name__)
+        self.project_name = project_name
+        self.out_dir = out_dir.absolute()
+        self.project_root_dir = self.out_dir.joinpath(self.project_name)
+        self.project_artifacts = WorkspaceArtifacts(self.project_root_dir)
+
+    @classmethod
+    def from_folder(cls, project_dir: Path) -> "Creator":
+        return cls(project_dir.name, project_dir.parent)
+
+    @staticmethod
+    def create_project_description(name: str, variants: List[Variant], touch_only_variants_data: bool = False) -> Dict[str, Any]:
+        project_description = {"name": name, "variants": {}, "touch_components": not touch_only_variants_data, "touch_tools": not touch_only_variants_data}
+        variants.sort()
+        for index, variant in enumerate(variants):
+            project_description["variants"] = {str(index): vars(variant) for index, variant in enumerate(variants)}
+        return project_description
+
+    @property
+    def project_template_path(self) -> Path:
+        return Path(__file__).parent.joinpath("templates/project")
+
+    @property
+    def variant_template_path(self) -> Path:
+        return Path(__file__).parent.joinpath("templates/variant")
+
+    def materialize(self, variants: List[Variant]) -> Path:
+        result_path = self.materialize_workspace(variants)
+        self.materialize_variants(variants)
+        self.logger.info(f"Project created under: {result_path}")
+        return Path(result_path)
+
+    def materialize_workspace(self, variants: List[Variant], touch_only_variants_data: bool = False) -> Path:
+        project_description = self.create_project_description(self.project_name, variants, touch_only_variants_data)
+        result_path = cookiecutter(str(self.project_template_path), output_dir=f"{self.out_dir}", no_input=True, extra_context=project_description, overwrite_if_exists=True)
+        return result_path
+
+    def materialize_variants(self, variants: List[Variant]) -> None:
+        for variant in variants:
+            self.materialize_variant(vars(variant), self.project_artifacts.variants_dir)
+
+    def materialize_variant(self, variant_description: Dict[str, Any], out_dir: Path) -> Path:
+        result_path = cookiecutter(str(self.variant_template_path), output_dir=f"{out_dir}", no_input=True, extra_context=variant_description, overwrite_if_exists=True)
+        self.logger.info(f"Variant created under: {result_path}")
+        return Path(result_path)
+
+    def add_variants(self, variants: List[Variant]) -> None:
+        existing_variants = self.collect_project_variants()
+        new_variants = [variant for variant in variants if variant not in existing_variants]
+        if len(new_variants):
+            self.materialize_workspace(new_variants + existing_variants, touch_only_variants_data=True)
+            self.materialize_variants(variants)
+            if len(new_variants) != len(variants):
+                self.logger.warning(f"Skip adding variants" f" ({', '.join([str(v) for v in variants if v not in new_variants])})" f" because they already exist in {self.project_root_dir}.")
+        else:
+            self.logger.warning(f"Nothing to add. All the provided variants" f" ({', '.join([str(v) for v in variants])}) already exist in {self.project_root_dir}.")
+
+    def delete_variants(self, variants: List[Variant]) -> None:
+        existing_variants = self.collect_project_variants()
+        variants_to_be_deleted = [variant for variant in variants if variant in existing_variants]
+        if len(variants_to_be_deleted):
+            remaining_variants = list(set(existing_variants) - set(variants_to_be_deleted))
+            self.materialize_workspace(remaining_variants, touch_only_variants_data=True)
+            for variant in variants_to_be_deleted:
+                self.delete_variant_dir(variant)
+            if len(variants_to_be_deleted) != len(variants):
+                self.logger.warning(f"Skip deleting variants" f" ({', '.join([str(v) for v in variants if v not in variants_to_be_deleted])})" f" because they do not exist in {self.project_root_dir}.")
+        else:
+            self.logger.warning(f"Nothing to delete. None of the provided variants" f" ({', '.join([str(v) for v in variants])}) exists in {self.project_root_dir}.")
+
+    def delete_variant_dir(self, variant: Variant) -> None:
+        variant_dir = self.project_artifacts.variants_dir.joinpath(f"{variant}")
+        if variant_dir.exists():
+            shutil.rmtree(variant_dir)
+
+    def collect_project_variants(self) -> List[Variant]:
+        variants = []
+        variant_dirs = self.project_artifacts.variants_dir.glob("*/*/")
+        for variant_dir in variant_dirs:
+            variants.append(Variant(variant_dir.parent.name, variant_dir.name))
+        return variants
+
+
+def main(command_arguments: Any = None) -> None:
+    arguments = parse_arguments(command_arguments)
+    if arguments.command_scope == "workspace":
+        Creator(arguments.name, arguments.out_dir).materialize(arguments.variant)
+    else:  # scope is variant
+        creator = Creator.from_folder(arguments.workspace_dir)
+        if arguments.add:
+            creator.add_variants(arguments.add)
+        else:
+            creator.delete_variants(arguments.delete)
+
+
+def parse_arguments(command_arguments: Any = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Workspace creator")
+    subparsers = parser.add_subparsers(dest="command_scope")
+
+    parser_workspace = subparsers.add_parser("workspace", help="Create a workspace")
+    parser_workspace.add_argument("--name", required=True, type=str, help="Workspace name. A directory with this name will be created in the <out_dir>.")
+    parser_workspace.add_argument("--variant", required=True, action="append", type=Variant.from_string, help="Variant name as <flavor>/<subsystem>. E.g. FLV1/SYS1. " "This option can be used multiple times.")
+    parser_workspace.add_argument("--out_dir", required=True, type=existing_path, help="Target directory where the workspace folder will be created.")
+
+    parser_variant = subparsers.add_parser("variant", help="Add/delete variant to existing workspace")
+    command_group = parser_variant.add_mutually_exclusive_group(required=True)
+    command_group.add_argument(
+        "--add", action="append", type=Variant.from_string, metavar="VARIANT", help="Add a variant to a workspace. Variant name as <flavor>/<subsystem>." " E.g. FLV1/SYS1. This option can be used multiple times."
+    )
+    command_group.add_argument(
+        "--delete", action="append", type=Variant.from_string, metavar="VARIANT", help="Delete a variant from a workspace. Variant name as <flavor>/<subsystem>." " E.g. FLV1/SYS1. This option can be used multiple times."
+    )
+    parser_variant.add_argument("--workspace_dir", required=True, type=existing_path, help="Workspace root directory.")
+    return parser.parse_args(command_arguments)
+
+
+if __name__ == "__main__":
+    main()

spl_core/project_creator/templates/project/cookiecutter.json

@@ -0,0 +1,14 @@
+{
+  "name": "project",
+  "touch_components": "True",
+  "touch_tools": "True",
+  "variants": {
+    "1": {
+      "flavor": "flavor",
+      "subsystem": "subsystem"
+    }
+  },
+  "_copy_without_render": [
+        "*.rst"
+    ]
+}

spl_core/project_creator/templates/project/{{cookiecutter.name}}/.flake8

@@ -0,0 +1,2 @@
+[flake8]
+max-line-length = 240

spl_core/project_creator/templates/project/{{cookiecutter.name}}/.gitignore

@@ -0,0 +1,33 @@
+# Binary output dir, not recommended to push binary results to Git.
+/build
+
+# Output directory of test results
+/test/output
+
+# What: Python: byte-compiled / optimized / DLL files
+# Why: automatically created by Python during script execution
+__pycache__/
+/.pytest_cache
+*.py[cod]
+*$py.class
+
+# Any log directory
+**/[Ll][Oo][Gg]/*
+
+# Any backup file of text editors
+*.bak
+
+# Any log file
+*.log
+
+# Backup files of KConfig
+*.old
+
+# Generated IDEA project files
+.idea
+
+# bootstrap files are downloaded during installation
+/.bootstrap
+
+# Drawio Backup Files
+*.drawio.bkp

spl_core/project_creator/templates/project/{{cookiecutter.name}}/.vscode/cmake-kits.json

@@ -0,0 +1,11 @@
+[
+  {
+    "name": "prod",
+    "environmentSetupScript": "${workspaceFolder}/.venv/Scripts/activate"
+  },
+  {
+    "name": "test",
+    "toolchainFile": "tools/toolchains/gcc/toolchain.cmake",
+    "environmentSetupScript": "${workspaceFolder}/.venv/Scripts/activate"
+  }
+]

spl_core/project_creator/templates/project/{{cookiecutter.name}}/.vscode/cmake-variants.json

@@ -0,0 +1,18 @@
+{
+  "variant": {
+    "choices": {
+{%- for variant in cookiecutter.variants.values() -%}
+      "{{ variant["flavor"] }}/{{ variant["subsystem"] }}": {
+        "buildType": "{{ variant["flavor"] }}_{{ variant["subsystem"] }}",
+        "long": "select to build variant '{{ variant["flavor"] }}/{{ variant["subsystem"] }}'",
+        "settings": {
+          "FLAVOR": "{{ variant["flavor"] }}",
+          "SUBSYSTEM": "{{ variant["subsystem"] }}"
+        },
+        "short": "{{ variant["flavor"] }}/{{ variant["subsystem"] }}"
+      }{{ ", " if not loop.last else "" }}
+{%- endfor -%}
+    },
+    "default": "{{ cookiecutter.variants["0"]["flavor"] }}/{{ cookiecutter.variants["0"]["subsystem"] }}"
+  }
+}

spl_core/project_creator/templates/project/{{cookiecutter.name}}/.vscode/extensions.json

@@ -0,0 +1,18 @@
+{
+        "recommendations": [
+            "mhutchie.git-graph",
+            "ms-vscode.cmake-tools",
+            "twxs.cmake",
+            "ms-vscode.cpptools",
+            "ms-vscode.cpptools-themes",
+            "visualstudioexptteam.intellicode-api-usage-examples",
+            "visualstudioexptteam.vscodeintellicode",
+            "haugerbr.project-tasks",
+            "avengineers.show-link-list",
+            "ms-python.vscode-pylance",
+            "ms-python.python",
+            "donjayamanne.python-environment-manager",
+            "felipecaputo.git-project-manager",
+            "ms-vscode.powershell"
+        ]
+}

spl_core/project_creator/templates/project/{{cookiecutter.name}}/.vscode/launch.json

@@ -0,0 +1,37 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "(gdb) Launch",
+            "type": "cppdbg",
+            "request": "launch",
+            "program": "${command:cmake.launchTargetPath}",
+            "args": [],
+            "stopAtEntry": true,
+            "cwd": "${command:cmake.launchTargetDirectory}",
+            "environment": [],
+            "externalConsole": false,
+            "MIMode": "gdb",
+            "miDebuggerPath": "gdb",
+            "setupCommands": [
+                {
+                    "description": "Enable pretty-printing for gdb",
+                    "text": "-enable-pretty-printing",
+                    "ignoreFailures": true
+                }
+            ]
+        },
+        {
+            "name": "Python: Debug Tests",
+            "type": "python",
+            "request": "launch",
+            "program": "${file}",
+            "purpose": [
+                "debug-test"
+            ],
+            "console": "integratedTerminal",
+            "env": {},
+            "justMyCode": false
+        }
+    ]
+}